{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.warmup预热学习率\n",
    "#### 2.learning rete  decay学习率衰减\n",
    "#### 3.nn.Linear()实现对前一层网络的线性组合\n",
    "#### 4.pad_sequence()填充句子长度\n",
    "##### [dataset、dataloader的应用](#data)\n",
    "#### 4-1.pack_padded_sequence将padding过的句子进行压缩，然后送入网络，避免无用的数据送入网络\n",
    "#### 5.weight decay权重衰减$L_2$正则化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import transformers\n",
    "import matplotlib.pyplot as plt\n",
    "from random import seed\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    "import torch.utils.data as data\n",
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.warmup预热学习率\n",
    "### What is warmup?\n",
    "* 它在训练开始的时候先选择使用一个较小的学习率，\n",
    "* 训练了一些epoches或者steps,再修改为预先设置的学习率来进行训练  \n",
    "\n",
    "### Why use it?\n",
    "* 刚开始训练时,模型的权重(weights)是随机初始化的\n",
    "    * 此时若选择一个较大的学习率,可能带来模型的不稳定(振荡)\n",
    "* 选择Warmup预热学习率的方式\n",
    "    * 可以使得开始训练的几个epoches或者一些steps内学习率较小\n",
    "    * 在预热的小学习率下，模型可以慢慢趋于稳定,等模型相对稳定后再选择预先设置的学习率进行训练,使得模型收敛速度变得更快，模型效果更佳。\n",
    "\n",
    "\n",
    "### the improvement of warmup\n",
    "* 它的不足之处在于从一个很小的学习率一下变为比较大的学习率可能会导致训练误差突然增大。\n",
    "* 于是18年Facebook提出了gradual warmup来解决这个问题，\n",
    "    * 即从最初的小学习率开始，每个step增大一点点，直到达到最初设置的比较大的学习率时"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_steps:100.000--warmup_steps:300.000--learning_rate:0.033\n",
      "train_steps:200.000--warmup_steps:300.000--learning_rate:0.066\n",
      "train_steps:300.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:400.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:500.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:600.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:700.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:800.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:900.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:1000.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:1100.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:1200.000--warmup_steps:300.000--learning_rate:0.100\n",
      "train_steps:1300.000--warmup_steps:300.000--learning_rate:0.097\n",
      "train_steps:1400.000--warmup_steps:300.000--learning_rate:0.095\n",
      "train_steps:1500.000--warmup_steps:300.000--learning_rate:0.093\n"
     ]
    }
   ],
   "source": [
    "warmup_steps = 300\n",
    "init_lr = 0.1\n",
    "\n",
    "max_epoch = 1500\n",
    "\n",
    "# 训练150000个轮次\n",
    "for train_steps in range(max_epoch):\n",
    "    # 在前warmp_steps轮次进行预热\n",
    "    if warmup_steps and train_steps < warmup_steps:\n",
    "        warmup_percent_done = train_steps / warmup_steps\n",
    "        warmup_learning_rate = init_lr * warmup_percent_done  \n",
    "        #gradual warmup_lr\n",
    "        learning_rate = warmup_learning_rate\n",
    "    elif train_steps < 1200:\n",
    "    #learning_rate = np.sin(learning_rate)  \n",
    "    #预热学习率结束后,学习率呈sin衰减\n",
    "        learning_rate = learning_rate \n",
    "    #预热学习率结束后,学习率呈指数衰减(近似模拟指数衰减)\n",
    "    else:\n",
    "        learning_rate = learning_rate ** 1.0001\n",
    "    if (train_steps+1) % 100 == 0:\n",
    "             print(\"train_steps:%.3f--warmup_steps:%.3f--learning_rate:%.3f\" % (\n",
    "                 train_steps+1, warmup_steps, learning_rate))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.learning rate decay学习率衰减\n",
    "在训练模型的时候，通常会遇到这种情况：  \n",
    "<font color=\"red\">**我们平衡模型的训练速度和损失（loss）后选择了相对合适的学习率（learning rate），但是训练集的损失下降到一定的程度后就不在下降了，比如training loss一直在0.7和0.9之间来回震荡，不能进一步下降**</font>  \n",
    "* 遇到这种情况通常可以通过适当**降低学习率**（learning rate）来实现。\n",
    "* 但是，**降低学习率又会延长训练所需的时间**。 \n",
    "***  \n",
    "### 学习率衰减（learning rate decay） 就是一种可以平衡这两者之间矛盾的解决方案。\n",
    "* 学习率随着训练的进行逐渐衰减。\n",
    "    + 线性衰减。例如：每过5个epochs学习率减半。  \n",
    "    + 指数衰减。例如：随着迭代轮数的增加学习率自动发生衰减，每过5个epochs将学习率乘以0.9998。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.nn.Linear()设置网络中的全连接层（线性层）\n",
    "<font color=\"green\">**其每个神经元与上一个层所有神经元相连接，实现对前一层的线性组合， 前一层的输出乘以权重、相加然后输出**</font>\n",
    "## 输入和输出都是二维张量$[batch\\_size, size]$  \n",
    "<font color=\"red\">$torch.nn.Linear(in\\_features, out\\_features, bias=True)$</font>  \n",
    "**in_features**:&nbsp;&nbsp;输入的二维张量的大小，即输入的 <strong>[batch_size, size] </strong>  中的size  \n",
    "**out_features：**&nbsp;&nbsp;输出的二维张量的大小，即输出的二维张量的形状为  <strong>[batch_size，output_size]</strong> ，当然，它也代表了该全连接层的神经元个数。\n",
    "\n",
    "* 从输入输出的张量的shape角度来理解:\n",
    "    * 相当于一个输入为  <strong>[batch_size, in_features]</strong>  的张量变换成了  <strong>[batch_size, out_features]</strong>  的输出张量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 12288])\n",
      "torch.Size([1, 10])\n"
     ]
    }
   ],
   "source": [
    "# in_features由输入张量的形状决定，out_features则决定了输出张量的形状 \n",
    "connected_layer = nn.Linear(in_features = 64 * 64 * 3, out_features = 10)\n",
    "# 实例化一个线性层， 也称为全连接层\n",
    "\n",
    "# 假定输入的图像形状为[64,64,3]\n",
    "input = torch.randn(1,64,64,3)# 一个batch一张图片\n",
    "\n",
    "# 将四维张量转换为二维张量之后，才能作为全连接层的输入\n",
    "input = input.view(1,64 * 64 * 3)\n",
    "print(input.shape)\n",
    "output = connected_layer(input) # 调用全连接层\n",
    "print(output.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.pad_sequence()填充句子长度\n",
    "<font size=4, color=\"red\">$$pad\\_sequence(sequences, batch\\_first=False, padding\\_value=0)$$</font>\n",
    "**在输入为一个batch的句子，输入的句子的长度必然是不同的，为了保证维度一致我们会把其中的短句子padding到和长句等长，但是我们又不希望这些padding的值参与训练，因此这里就是告诉RNN模型输入的padding情况。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[10.,  3.,  4.,  5.],\n",
       "        [ 6.,  5.,  4., -1.],\n",
       "        [ 5.,  6.,  8., -1.]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_in = [torch.Tensor([10,3,4,5]),torch.Tensor([6,5,4]),torch.Tensor([5,6,8])]\n",
    "\n",
    "pad = nn.utils.rnn.pad_sequence(test_in, batch_first=True, padding_value=-1)\n",
    "pad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* pad_sequence()填充，<font color=\"blue\"><span id=data>data和datasets库的应用</span></font>\n",
    "    * shuffle数据后，先条一条的读取数据，当读满一个batch_size时,把数据送福collate_fn进一步处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1, 1, 1, 1, 1, 1, 1],\n",
      "        [2, 2, 2, 2, 2, 2, 0],\n",
      "        [3, 3, 3, 3, 3, 0, 0],\n",
      "        [4, 4, 4, 4, 0, 0, 0],\n",
      "        [5, 5, 5, 0, 0, 0, 0],\n",
      "        [6, 6, 0, 0, 0, 0, 0],\n",
      "        [7, 0, 0, 0, 0, 0, 0]])\n",
      "====================万能的分隔符====================\n",
      "====================我现在在Mydata里====================\n",
      "tensor([5, 5, 5])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([2, 2, 2, 2, 2, 2])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([7])\n",
      "collate_fn的batch：\n",
      " [tensor([5, 5, 5]), tensor([2, 2, 2, 2, 2, 2]), tensor([7])]\n",
      "pad之后的batch：\n",
      " tensor([[2, 2, 2, 2, 2, 2],\n",
      "        [5, 5, 5, 0, 0, 0],\n",
      "        [7, 0, 0, 0, 0, 0]])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([6, 6])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([4, 4, 4, 4])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([1, 1, 1, 1, 1, 1, 1])\n",
      "collate_fn的batch：\n",
      " [tensor([6, 6]), tensor([4, 4, 4, 4]), tensor([1, 1, 1, 1, 1, 1, 1])]\n",
      "pad之后的batch：\n",
      " tensor([[1, 1, 1, 1, 1, 1, 1],\n",
      "        [4, 4, 4, 4, 0, 0, 0],\n",
      "        [6, 6, 0, 0, 0, 0, 0]])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([3, 3, 3, 3, 3])\n",
      "collate_fn的batch：\n",
      " [tensor([3, 3, 3, 3, 3])]\n",
      "pad之后的batch：\n",
      " tensor([[3, 3, 3, 3, 3]])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([3, 3, 3, 3, 3])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([6, 6])\n",
      "====================我现在在Mydata里====================\n",
      "tensor([1, 1, 1, 1, 1, 1, 1])\n",
      "collate_fn的batch：\n",
      " [tensor([3, 3, 3, 3, 3]), tensor([6, 6]), tensor([1, 1, 1, 1, 1, 1, 1])]\n",
      "pad之后的batch：\n",
      " tensor([[1, 1, 1, 1, 1, 1, 1],\n",
      "        [3, 3, 3, 3, 3, 0, 0],\n",
      "        [6, 6, 0, 0, 0, 0, 0]])\n"
     ]
    }
   ],
   "source": [
    "import torch.utils.data as data\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "train_x = [torch.tensor([1, 1, 1, 1, 1, 1, 1]),\n",
    "           torch.tensor([2, 2, 2, 2, 2, 2]),\n",
    "           torch.tensor([3, 3, 3, 3, 3]),\n",
    "           torch.tensor([4, 4, 4, 4]),\n",
    "           torch.tensor([5, 5, 5]),\n",
    "           torch.tensor([6, 6]),\n",
    "           torch.tensor([7])]\n",
    "#  正常操作\n",
    "x = pad_sequence(train_x, batch_first=True)\n",
    "print(x)\n",
    "print(20*\"=\" + \"万能的分隔符\"+ 20*\"=\")\n",
    "\n",
    "class MyData(data.DataLoader):\n",
    "    def __init__(self, data_seq):\n",
    "        self.data_seq = data_seq\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data_seq)\n",
    "    \n",
    "    def __getitem__(self, idx): \n",
    "        print(20*\"=\" + \"我现在在Mydata里\"+ 20*\"=\")\n",
    "        print(self.data_seq[idx])\n",
    "       \n",
    "        return self.data_seq[idx]\n",
    "\n",
    "def collate_fn(batch):# 这个batch 是一个getitem的结果\n",
    "    print(\"collate_fn的batch：\\n\", batch)\n",
    "    \n",
    "    batch.sort(key=lambda x: len(x), reverse=True)\n",
    "    batch = pad_sequence(batch, batch_first=True, padding_value=0)\n",
    "    print(\"pad之后的batch：\\n\",batch)\n",
    "    return batch\n",
    "    \n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # 实例化读取data的对象\n",
    "    data = MyData(train_x)\n",
    "    # 加载数据\n",
    "    data_loader = DataLoader(data, batch_size=3, shuffle=True, collate_fn=collate_fn)\n",
    "\n",
    "    for data in data_loader:\n",
    "        data\n",
    "\n",
    "    batch_x = iter(data_loader).next()\n",
    "    # next() 函数要和生成迭代器的 iter() 函数一起使用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4-1.pack_padded_sequencepad过的句子进行压缩，然后送进网络进行训练,避免了无用的数据送入网络\n",
    "该操作是将pad过的句子进行压缩，然后送进网络进行训练，避免了无用的数据送入网络。\n",
    "\n",
    "pack_padded_sequence 有三个参数：input, lengths, batch_first 。\n",
    "\n",
    "* input 是上一步加过 padding 的数据，\n",
    "* lengths 是各个 sequence 的实际长度，\n",
    "* batch_first 是数据各个 dimension 按照 $[batch\\_size, sequence\\_length, data\\_dim]$顺序排列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pack: PackedSequence(data=tensor([1, 3, 6, 1, 3, 6, 1, 3, 0, 1, 3, 1, 3, 1, 1]), batch_sizes=tensor([3, 3, 3, 2, 2, 1, 1]), sorted_indices=None, unsorted_indices=None)\n"
     ]
    }
   ],
   "source": [
    "length = [7, 5, 3]\n",
    "pack= nn.utils.rnn.pack_padded_sequence(batch_x, length, batch_first=True)\n",
    "print('pack:',pack)# 数据以列的方式进行读取"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.weight decay权重衰减\n",
    "**$L_2$正则化：**让权重衰减到更小的值，在一定程度上**减少模型过拟合**的问题，所以**权重衰减也叫$L_2$正则化**。\n",
    "***\n",
    "### $L_2$正则化可以避免模型过拟合\n",
    "+  L2正则化项有让w变小的效果，但是为什么w变小可以防止过拟合呢？\n",
    "    1. 从模型的复杂度上解释\n",
    "        * 更小的权值w，从某种意义上说，表示网络的复杂度更低，对数据的拟合更好（这个法则也叫做奥卡姆剃刀）\n",
    "    2. 从数学方面的解释\n",
    "        * 过拟合的时候，拟合函数的系数往往非常大\n",
    "        * 过拟合就是**拟合函数需要顾忌每一个点，最终形成的拟合函数波动很大**。\n",
    "        * <font color=\"red\">在某些很小的区间里，函数值的变化很剧烈</font>\n",
    "            * 这就意味着函数在某些小区间里的**导数值（绝对值）非常大**，\n",
    "                * <font color=\"blue\">由于自变量值可大可小，所以只有系数足够大，才能保证导数值很大</font>。\n",
    "                * 正则化是通过约束参数的范数使其不要太大，所以可以在一定程度上减少过拟合情况。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed(1)\n",
    "\n",
    "n_hidden = 200 # 隐藏层神经单元数量\n",
    "max_iter = 200 # 迭代次数\n",
    "disp_interval = 50 # 每200轮进行一次绘图显示\n",
    "lr_init = 0.01 #学习率\n",
    "\n",
    "\n",
    "# ============================ step 1/5 数据 ============================\n",
    "def gen_data(num_data=100, x_range=(-1, 1)):\n",
    "\n",
    "    w = 1.5 # 定义权重\n",
    "    train_x = torch.linspace(*x_range, num_data).unsqueeze_(1)# [10, 1]\n",
    "    #定义数据集X，*x_range表示将参数名为x_range的内容打散，即生成-1到1的10个数并扩展维度\n",
    "    train_y = w*train_x + torch.normal(0, 0.5, size=train_x.size())\n",
    "    \n",
    "    test_x = torch.linspace(*x_range, num_data).unsqueeze_(1)\n",
    "    test_y = w*test_x + torch.normal(0, 0.3, size=test_x.size())\n",
    "\n",
    "    return train_x, train_y, test_x, test_y\n",
    "\n",
    "\n",
    "train_x, train_y, test_x, test_y = gen_data()\n",
    "\n",
    "# train_x,test_y,test_x,test_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ============================ step 2/5 模型 ============================\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, neural_num):\n",
    "        super(MLP, self).__init__()\n",
    "        self.linears = nn.Sequential(# 利用容器简历模型\n",
    "            nn.Linear(1, neural_num),\n",
    "            # [batch_size, size]\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(neural_num, neural_num),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(neural_num, neural_num),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Linear(neural_num, 1),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.linears(x)\n",
    "\n",
    "\n",
    "net_normal = MLP(neural_num=n_hidden)\n",
    "net_weight_decay = MLP(neural_num=n_hidden)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ============================ step 3/5 优化器 ============================\n",
    "# 不添加L2正则\n",
    "optim_normal = torch.optim.SGD(net_normal.parameters(), lr=lr_init, momentum=0.9)\n",
    "\n",
    "# 添加L2正则\n",
    "optim_wdecay = torch.optim.SGD(net_weight_decay.parameters(), lr=lr_init, momentum=0.9, weight_decay=1e-2)\n",
    "\n",
    "# ============================ step 4/5 损失函数 ============================\n",
    "loss_func = torch.nn.MSELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAEICAYAAABiXeIWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydeXxU1d3/3zd3smcSMlkgAwlhiQJCCBBkk8WF3foTLWiqtmhRaV1bi1vrVp/28bHWWrTuKNZSVMCtBCyoaEAWCRiQfScJAyQwyZA9mcn9/XEyyUwyk0ySGTJJzvv1ygsy9865596ZnM/5Lud7FE3TkEgkEonE2wR0dAckEolE0jWRAiORSCQSnyAFRiKRSCQ+QQqMRCKRSHyCFBiJRCKR+AQpMBKJRCLxCVJgJJJGKIqiKYoysKP7IZF0dqTASPwaRVFOKIpSoShKqcPPKx3dL3coijJfURRbo/5OcTierCjKBkVRyhVFOaAoyjUd2F2JxKfoOroDEokH/ETTtC87uhOtYIumaVe4ObYc2ALMqvtZqShKiqZphRetdxLJRUJaMJJOS5218J2iKC8rimKpswiudjhuVBTlc0VRzIqiHFEU5U6HY6qiKI8rinJUUZQSRVF2KIqS6ND8NYqiHFYUpUhRlH8oiqJ4ob+XACOBpzRNq9A0bRXwI3Bje9uWSPwRKTCSzs4Y4BgQCzwFfKwoiqHu2HIgHzACPwX+7CBAvwUyEFZEJHAHUO7Q7rXAaGA4MA+YDqAoSpKiKMWKoiQ106cRiqKcUxTlkKIoTyiKYvcUXAYc0zStxOHcXXWvSyRdDikwks7Ap3WDuv3nTodjBcBLmqbVaJr2IXAQmF1njVwBPKJpWqWmaTnA28Btde9bAPxB07SDmmCXpmnnHdp9TtO0Yk3TcoENQBqApmm5mqb1qHvdFVnAUCAeYZlkAIvqjkUAlkbnWwB9q5+IRNIJkAIj6QxcXzeo23/ecjh2SnOu2HoSYbEYAXMja+Ek0Lvu/4nA0Wauecbh/+UIcWgRTdOOaZp2XNO0Wk3TfgT+iLCeAEoR1pIjkUAJEkkXRAqMpLPTu1F8JAkw1f0YFEXRNzp2qu7/ecCAi9A/DbD3by/Qv1Gfhte9LpF0OaTASDo78cD9iqIEKooyFxgMrNE0LQ/YDPyvoighiqKkAr8EltW9723gWUVRUhRBqqIoMe3tjKIoMxVF6Vn3/0HAE8BnAJqmHQJygKfq+jQHSAVWtfe6Eok/ItOUJZ2B/yiKYnP4fb2maXPq/r8NSAHOAWeBnzrEUjKA1xHWTBEie2t93bEXgWBgHSJB4ABgb9MtdcH9fcAQN3GYq4GliqJE1PXnX8CfHY7fDCyt609uXX9lirKkS6LIDccknRVFUeYDC5pZcyKRSDoQ6SKTSCQSiU+QAiORSCQSnyBdZBKJRCLxCdKCkUgkEolP6JAsstjYWC05ObkjLi2RSCSdlh07dpzTNC2uo/vhKR0iMMnJyWRnZ3fEpSUSiaTToijKyY7uQ2uQLjKJRCKR+AQpMBKJRCLxCVJgJBKJROIT/KZUTE1NDfn5+VRWVnZ0VyReIiQkhD59+hAYGNjRXZFIJB2A3whMfn4+er2e5ORkvLB5oKSD0TSN8+fPk5+fT79+/Tq6OxKJpAPwGxdZZWUlMTExUly6CIqiEBMTIy1SiaQb4zcCA0hx6WLIz1Mi6d74lcBIJBKJpOsgBaaDyc7O5v7772/2nBMnTjB06FCXx5YuXYrJZGrxOs21IZFIJL7Ab4L83ZX09HTS09Pb/P6lS5cydOhQjEajF3slkUgaY7WCyQSlpRARAUYj6OQI2izSgqnjxIkTDB48mDvvvJPLLruMadOmUVFRAUBOTg5jx44lNTWVOXPmUFRU5PRem81G//790TSN4uJiAgICyMrKAmDixIkcOXKEsrIy7rjjDkaPHs2IESP47LPPAPjmm2+49tprASgsLGTq1KmMHDmSu+++m759+3Lu3Ln6azTu28qVK8nOzuaWW24hLS2tvr92duzYwfDhwxk3bhz/+Mc/nPq7aNEiRo8eTWpqKm+88Ub9seeff55hw4YxfPhwHn30UQDeeustRo8ezfDhw7nxxhspLy+npKSEfv36UVNTA8CFCxdITk6u/10i6UqYzbB8OaxeDRs3in+XLxevS9zjnwKjKL77aYbDhw9zzz33sHfvXnr06MGqVWKr9J///Of83//9H7t372bYsGE888wzTu9TVZVLLrmEffv2sWnTJkaNGsXGjRupqqoiPz+fgQMH8qc//YmrrrqK7du3s2HDBhYtWkRZWZlTO8888wxXXXUVO3fuZM6cOeTm5jbbt5/+9Kekp6ezbNkycnJyCA0NdWrv9ttvZ/HixWzZssXp9SVLlhAVFcX27dvZvn07b731FsePH2ft2rV8+umnbNu2jV27dvHwww8DcMMNN7B9+3Z27drF4MGDWbJkCXq9nilTppCZmQnABx98wI033ijXvEi6HFYrZGaK4SMxUVguiYni98xMcVziGv8UmA6iX79+pKWlATBq1ChOnDiBxWKhuLiYyZMnA/CLX/yi3jpxZOLEiWRlZZGVlcVjjz3Gpk2b2L59O6NHjwZg3bp1PPfcc6SlpTFlyhQqKyudBARg06ZN3HzzzQDMmDGD6OjoZvvWHI37fdttt9UfW7duHf/85z9JS0tjzJgxnD9/nsOHD/Pll19y++23ExYWBoDBYABgz549TJw4kWHDhrFs2TL27t0LwIIFC3j33XcBePfdd7n99ttbesQSSafDZIKSEoiKcn49Kkq87kEItNsiBcaB4ODg+v+rqoq1FVOTiRMnsnHjRr7//ntmzZpFcXEx33zzDZMmTQLEwsNVq1aRk5NDTk4Oubm5DB482KmN5jZ/a23fNE1zmyasaRovv/xyfV+OHz/OtGnT3L5n/vz5vPLKK/z444889dRT9WtbJkyYwIkTJ/j222+x2WwyiUDSJSktBVV1fUxVoZEjQuKAfwqMpvnup5VERUURHR3Nxo0bAXj//ffrrQJHxowZw+bNmwkICCAkJIS0tDTeeOMNJk6cCMD06dN5+eWX60Xkhx9+aNLGFVdcwUcffQQIK6NxrMcVer2ekpKSJq/36NGDqKgoNm3aBMCyZcvqj02fPp3XXnutPl5y6NAhysrKmDZtGu+88w7l5eUAmOsczCUlJSQkJFBTU+PUDgj3YUZGhrReJF2WiAiw2Vwfs9kgPPzi9qcz4Z8C42e89957LFq0iNTUVHJycnjyySebnBMcHExiYiJjx44FhEVTUlLCsGHDAHjiiSeoqakhNTWVoUOH8sQTTzRp46mnnmLdunWMHDmStWvXkpCQgF6vb7Zv8+fPZ+HChS6D/O+++y733HMP48aNc4rPLFiwgCFDhjBy5EiGDh3K3XffjdVqZcaMGVx33XWkp6eTlpbGCy+8AMCzzz7LmDFjmDp1KoMGDXK6xi233EJRUREZGRkePEmJpPNhNIJeDxaL8+sWi3hdJnC6R2nOLeMr0tPTtcYbju3fv7+Jy6i7UVVVhaqq6HQ6tmzZwq9+9StycnI6ulvNsnLlSj777DPef/99l8fl5yrpCpjNIqBfUiLcYjabEJfZs6EuVHlRUBRlh6ZpbV/XcJFpdxa3oiiJwD+BXkAt8KamaX9vb7vdkdzcXObNm0dtbS1BQUG89dZbHd2lZrnvvvtYu3Yta9as6eiuSCQ+xWCAjAwR0C8rE24xuQ6mZbzxeKzAQ5qm7VQURQ/sUBRlvaZp+7zQdrciJSXFZWzGX3n55Zc7ugsSyUVDp4OkpI7uReei3QKjadpp4HTd/0sURdkP9AakwEgkkk6BXKXvG7z6CBVFSQZGANtcHLsLuAsgSU4DJBKJn+Av8ZWuiNeyyBRFiQBWAQ9qmnah8XFN097UNC1d07T0uLg4b11WIpFI2oxcpe9bvCIwiqIEIsRlmaZpH3ujTYlEIvE1cpW+b2m3wChi6fcSYL+maS+2v0udjwULFrBvX/Mhp/nz57Ny5comr584cYJ///vfHl3HXRsSid9itUJuLuzbJ/71M5NArtL3Ld6IwUwAbgN+VBTFvmjjcU3Tuk3u6ttvv93m99oF5mc/+5kXeySR+AGdILghV+n7lnZbMJqmbdI0TdE0LVXTtLS6n04nLs8//zyLFy8G4De/+Q1XXXUVAF999RW33norIMq3jBs3jpEjRzJ37lxKS0sBmDJlCvaFo0uWLOGSSy5hypQp3Hnnndx7773118jKymL8+PH079+/3hJ59NFH2bhxI2lpafztb39z6pOmadx7770MGTKE2bNnU1BQUH9sx44dTJ48mVGjRjF9+nROnz4NwJEjR7jmmmsYPnw4I0eO5OjRo5SWlnL11VczcuRIhg0bVr9VwBNPPMHf/96wZOn3v/99/TOQSNpFJwluyFX6vsVvS8U8/bTnFfjvuqvp+++6y/mcp59u/nqTJk2qrzeWnZ1NaWkpNTU1bNq0iYkTJ3Lu3Dn+53/+hy+//JKdO3eSnp7Oiy86ewRNJhPPPvssW7duZf369Rw4cMDp+OnTp9m0aROrV6+u32vlueeeY+LEieTk5PCb3/zG6fxPPvmEgwcP8uOPP/LWW2+xefNmAGpqarjvvvtYuXIlO3bs4I477uD3v/89IEq33HPPPezatYvNmzeTkJBASEgIn3zyCTt37mTDhg089NBDaJrGL3/5S9577z0Aamtr+eCDD7jllls8+XgkkubxQnDjYnjXdDphUGka5OWJbuXlid9nz5apyu1FPr46Ro0axY4dOygpKSE4OJiRI0eSnZ3Nxo0bWbx4MVu3bmXfvn1MmDABgOrqasaNG+fUxvfff8/kyZPry9zPnTuXQ4cO1R+//vrrCQgIYMiQIZw9e7bFPmVlZZGRkYGqqhiNxnqr6uDBg+zZs4epU6cCYgOxhIQESkpKOHXqFHPmzAEgJCQEEIL0+OOPk5WVRUBAAKdOneLs2bMkJycTExPDDz/8wNmzZxkxYgQxMTHtfJISCe0OblxM75rPVunLxTVSYOwEBgaSnJzMu+++y/jx40lNTWXDhg0cPXqUwYMHc/ToUaZOncry5cvdttFSXTfHkvue1oBzVT5f0zQuu+yyJhuJXbjQJDscEJWUCwsL2bFjR/192kvuL1iwgKVLl3LmzBnuuOMOj/okkbRIO4Ibjb1rdiwW8XpGhvfHaa+v0u8E8aeLgV+7yDytwP/mm03f/+abzue05CID4SZ74YUXmDRpEhMnTuT1118nLS0NRVEYO3Ys3333HUeOHAGgvLzcyToBuPzyy/n2228pKirCarXW74jZHO7K7dv788EHH2Cz2Th9+jQbNmwA4NJLL6WwsLBeYGpqati7dy+RkZH06dOHTz/9FBDFM8vLy7FYLMTHxxMYGMiGDRs4efJk/TXmzJnDF198wfbt25k+fXrLD0ki8YR2BDda8q7l5vp1YlqniT9dDPxWYDqCiRMncvr0acaNG0fPnj0JCQmp388lLi6OpUuXkpGRQWpqKmPHjm0SY+nduzePP/44Y8aM4ZprrmHIkCFENf4raURqaio6nY7hw4c3CfLPmTOHlJQUhg0bxq9+9av6fWiCgoJYuXIljzzyCMOHDyctLa0+PvP++++zePFiUlNTGT9+PGfOnOGWW24hOzu7fntlx5L7QUFBXHnllcybNw/VnUtDImkt7QhuNOddq6yEjz6C1ath40bx7/LlwmDwG+TimnpkuX4vU1paSkREBFarlTlz5nDHHXfUx0T8kdraWkaOHMmKFStISUnxevtd5XOVtBF7HKIVwY3cXCEcju4xEF6mTz6BkSOhf/+G1y0WoVu+cJ21iX37hPq5stJMJpg0Cdr4N9HZyvVLC8bLPP3006SlpTF06FD69evH9ddf39Fdcsu+ffsYOHAgV199tU/ERSKpD24MHiz+9UAB3HnXTpwQXqa+fZ1f9zvDQC6uqccf9L5LYd8FsjMwZMgQjh071tHdkEicsHvXMjOFV80eI6+ogNRU1+6ztqy691mSl6NCOrrJuuHiGikwEonE73CVOmy1whdfuD6/tYaBT5O83Cmk/QJ+4ce7OHSfO5VIJJ2KxqnDVqt3DAOvp0G7MoXkFpiAFBiJRNJJ8JZhYE/yapxEEBXVkPDm8ZqYxqZQdbUQnLFjoXfvbikqjnTfO5dIJJ0ObxgGXqug3NgUKimB7GwhOrt3w6hRQrW62eJKR2QWWR3FxcW8+uqrrX7frFmzKC4u9kGPJBKJK9qQmOaE15K8HNe72GxCXECITUgItuAwzpkV8t/IJPeYtTutr6yn0wqMtwvhuRMYm7tvYh1r1qyhR48e7bu4RCJpE20ZB7xWQdnRFDKboby8Xp0qqgPYvqmSbQeiOLa7hG/+bfK/BaEXgU7pIvNFBsijjz7K0aNHSUtLIzAwkIiICBISEsjJyWHfvn1cf/315OXlUVlZyQMPPMBddSWck5OT66svz5w5kyuuuILNmzfTu3dvPvvsM0JDQ7145xKJ/9DRtRzbOg60GMvBCrke3JijKVRRAaqKrRYuWODYnlpK+ocQ0wdCA1QSDWWcUnxXS81f6XS36atCeM899xx79uwhJyeHb775htmzZ7Nnzx769esHwDvvvIPBYKCiooLRo0dz4403Nqk8fPjwYZYvX85bb73FvHnzWLVqVf1eMhJJV6Kjazm2dxxwG8u5YIblHt6YoykUGkpluY1D+VBeWMb54lByiwwE7oFUgw1bSHjbkgg6OZ3ORXaxyvxcfvnl9eICsHjxYoYPH87YsWPJy8vj8OHDTd7Tr18/0tLSAFH+/8SJE97pjETiR/hDLcdWjQNu/GhNYjm08sYc6q3ZSsrIO1JFmDmP4GA4m5SOPkolpMrCEVM4ZRE9ge63DXOns2Au1h7a4Q6Rvm+++YYvv/ySLVu2EBYWxpQpU+rL3TviWI5fVVUqKiq80xmJxI/wappvG/F4HGiNqdWaG3P0D06YwBkT7MpL59LirVRUBBJ1OI/+Z/YQaz5MzLmDfJOWjO2Kyd2tUkznExhflflprmy+xWIhOjqasLAwDhw4wNatW9t2EYmkC9CaSZ5HcZo2BHM8Ggda60fz9MZciJZWFE6I1UiIpZC+Wz9jfP4+p7f3yvmCfcMmd7dKMZ1PYHxV5icmJoYJEyYwdOhQQkND6dmzZ/2xGTNm8Prrr5Oamsqll17K2LFj23kXEknnxdNJnkfGQxuDOR6NA601tTy5MUfRio2FXbvg++8xbttOnxKL6/cCPY7u6JbbMHfKcv0dHWCUeI4s19/1sFrFHiyK0nRwt5fNh5bP0eFBQ82Mxs2OA5FW+PZbyMoS5ZcNBmfrxFXZfE9ubOtW+Pvf4ehR+PFHtwGnWl0g5wdP5EDf6RzqP4Mr7x9GUl+l3eLS2cr1d0otlWV+JJ2Vjk7t9QaelGzJzfXAeKB9wZwWM8FOnoRDh6CgAEJDIT1ddBJc+9Nd3Vh1NZw5AxcuwJ//DI02GXTEFhrBsQHXcHjMbZwZNhVzjZ7qali4sPtOfDvZV7sBr++hLZH4GF9Z3h0hWi1N8jwKZ2jtz9hpMg44urCGDnVe2ZidLayW0lL3/nSDAWbMEJZMZibapk0oFy64vX5lr77k9rycguTR1AaH8pFyE+s3xmH+DM6dE8099liLt9Fl6bQCI5F0Jny1fqsj3cXuJnlWq7iv/HwIDGzqnWowHrycsWO1wvbtwmqxLzFITxfCUl4OFgu2H3Zh0SIpvnQswdtN9BxhRBeiEy6vzz8XPxs31vdLcWj+PAZy1FHsib2S7wPGUBUZzxV9joMGsZUW+idoKIqBQ4ca3mM2CwPKIaTbrZACI5FcBHyR2usN0fK29WMXvOJiITB5eUJg7N4p52QcL2bs2C988CAcPy7MB7tbbNIkMJspyznIsR0VFIXFwJFdhJ/7jNrCfRhLD6EeOVjflI0ADnMpOaSxi+HsCBzL7oARnK3qATbgrDjPUFTO9XHfERlho0TTs0aZjTGxQUmDg2HQIDh/XgqMRCLxIo0H7uJi76/faq9otcX6aU6QHAUvORliYhqKC69f71xcWLynjfX3G3ciPr7hwv37w7lz2AyxlBWUUf1FNtrESURFGTi94zRquIGUc19iOLCFYEtBk6b3M4hR7KCCsIYXa9w8v8ow9sRdSWyfEEr0Rs6bdRij4PHHhbjccIPw0nVnpMBIJF7G1cBdVSXGRVeT8rau32rPouO2WD8tCVJjwdPr640Hjh8XAjN6dKN2W5ux09zDHTQIbDYqlDCO7SijXAkntLSA6tObqTq6hYS83ey3pvAto8nmz2STznqmEk8hWlAwyvRpJE+/nuoHQoWl0ojAQOjVS3Rt+HAh3ufKLiGwzvgKqKuLMnas0MvISPfPv7sgBaaO4uJi/v3vf/PrX/+61e996aWXuOuuuwgLC2v5ZEmXxt3AbTbD5s1isu1oHbRn/VZ7Fh23yvqxWrHmmtj4YSnhoRFEJxvRVF19/+2C5ErwVBXi4qCmBnr0cKMbnmbsuHu4e/cK11hKCjZUsrURJJ77DKuphJyCBL639WEbL5BDGtUEOzX5dfIdDEu0EHr/nfT/6UhCgUGvQWGhWOYyeLAwipKTxWdkNsO6dTBtmvgcs7IadLG2FkJC2r8mryvReQXGy85je7n+tgrMrbfeKgVG4nbgNhhg4EAxQJWVeWeb9vYsOm5tqRXLyRIi96rERNmw5uopSJ9Njd7gJEi+qrJRj7uHGx8PO3fCxo1UZ+9h2Xc/5WPbqxQS32KTG/rOJ6HX1wzsHVv/2tatQihcLYlRVfG7qoofew5BXp44t7xcWDrdbUGlOzrnI/BB6oxjuf6pU6cSHx/PRx99RFVVFXPmzOGZZ56hrKyMefPmkZ+fj81m44knnuDs2bOYTCauvPJKYmNj2bBhg5dvVtKZaG7gjoyE8ePFAOWN9Vvt2UK4taVWyqITqTJApQF0ZRbiszMxTcpAU3X1gpSS4psqG/U4PNyi0kA2/RiFoeAAE3I/EKZEVRWhQBm3uhWXnuElDOt7gcEJxQwxWuivy0UN1NNzREPnIiLEv+6e7cMPC2vU/nq/fkLzxo0T99gZ1zb5is73GHyU7+lYrn/dunWsXLmS77//Hk3TuO6668jKyqKwsBCj0UhmZmbdJS1ERUXx4osvsmHDBmJjY1u4iqSr09LAHRXl3fVbbV103NpSK6HVYKsV51jDowgpzCPEbKIiLqlekNojeC1RWgrfbIvl6w8uZ8OBXuw60xONAOaRywTWO507lq38i9uIDChlcHI5/dJjuWRQACEVRaSdWk2YrQRFVdGqbaihei57eLZIVW7p2QZbMWJCV1lK3wkRmDBSVqWTC72bofM9kotQynXdunWsW7eOESNGAFBaWsrhw4eZOHEiv/vd73jkkUe49tprmThxYruuI+l6+KpWXnO0ZdGxR2LgYDEYDBAW2iBimqqiVpY1uS9vVdnQNFFdPzMTvlhby6ZNUGONh0aWyUYmolG3XsVopHbaDJJqr+TvvU6RPKYnSqAwR0S1l2iufDKD8z+aqDxfRkhMeMM6GDcu9/pn28hrorPZSJL1qVqk8wnMRajXr2kajz32GHfffXeTYzt27GDNmjU89thjTJs2jSeffLLd15N0LN4M5/lyFu9tWhQDB3PMMd5QeA70xTbyzOEoLu6rvVU2du6EG2/UOHHCvsyx6bZVAdgYxQ4mBW+jauK1hDx0D0ybRkBAABPMUJwJ+WeaPv+QCB29xzXqXEsud1+tku0GdL6n4qNIomO5/unTp/PEE09wyy23EBERwalTpwgMDMRqtWIwGLj11luJiIhg6dKlTu+VLrLOhy9WwnemWnnNikEjc8yedlx00kJVhZ7keUaMSe27r/JyEVC3p/iyfz/93l9B3onHaTw8pbKLqaznypjdTJwVSeSM8TD+J9DnV06daNXz90Q8/GEDnE6KV77yiqK8A1wLFGia5tulRT7yQTiW6585cyY/+9nPGDduHAARERH861//4siRIyxatIiAgAACAwN57bXXALjrrruYOXMmCQkJMsjfifDlxNTfauW1yUpzYY6pNhuxhjoFjgRMua02/S5cEE2uWgVr18IXHxZz2c5/Ebrin4Tu2U40MIHJ5JDGdP7LLNYwvecuEm6eDHPnwrjfOiiS+6579Pw9EY+LtcthF8Qr5foVRZkElAL/9ERg2luuX9br7zz4c7n+3FxYvbrp2AJibLn2Wv8SibbS7j8Xuzo5mgN2lahr1FZjo6hGz7kxswnrY2iiNcXFoszXihViHUl1dcOxh5S/8oL2O6dL5tOb+B41BN00B372M7jiihZFpU3s2ydqj7mamNpL+oeH+80XpVuW69c0LUtRlGRvtOURnckHIfFbusPE1CtWWmNzoFGjJSUiNmM1W1B3Z3JwZAYRPXRcfTV89x28/z7897/OouLIPq1hAlKrCyQ/7Sccm3Abvf40E8KDXb/JW3jicu+IzI0uQucdkf3NByHpdPh0YaCfbPzik/CBQ6M2mxAXgKhEkb5cG27iP9lJLFwoYiyuSOMHbmQVN/AxQ9hPacJATs64m7xr7qBGbyAvD/qfhyRf71/viXh0pswNP+OiPRlFUe4C7gJIcvON1jQNRVFcHpN0Pjpit9TW4LOJqR+5cH1ipTk0ajZDeQXE1eW32NOXB/Wvprw8yOltI9nBXFYwlxUM4BhWQzwn+k1h15gHsAWHAxrWsMj29a21eCoe0mvSJi7a09E07U3gTRAxmMbHQ0JCOH/+PDExMVJkugCapnH+/HlCQkI6uitu8cnE1M9SWn1ipTk0uvt4BG9sSub+6QeJDK0hpDCPAZ/+lQlbP2UJX1BEND/nn9zCMgZyVFxw2DD4yS8pir+MgzsCiKvTXFeLN+txZxF6w1L0VDyk16TV+I389unTh/z8fAoLCzu6KxIvERISQp8+fTq6G83i9YlpG31SnoyTbRlLfWGlaQlGvs5N4a9vDGHt7t4ADLHt5g/FvyPi9JH689YwizgKxYTxqqtg/tOi4vGOHWA0YrC1sHgz3gq5JrGxzLZtoshXYGDDLGD8eFGzxRuWohQPn+CtNOXlwEESo3MAACAASURBVBQgVlGUfOApTdOWtKaNwMBA+tl3oZNILiJeHVva4JPyxKPWVq+bKyutttpKvNXE1WNL0Zk8n/VXV8OHH8KLL+rIyZnqdGz5/jT+h+NOr4XFhlH766dRb/+FKEds33GybqtL1WAgPV11uXjz2vFmdCvqdi7buVMs7XfcucxshuefFyLjL7utSZrgrSyyDG+0I5F0elrpk/LEowbt87o5WmkVp8zEbM0kOrAEdbcKP7SsVMXF8MYbsHixaMMRhVqu43Me5CVUbNQGqJzrnUrBsKn0fmkRESl1wRk3W13q09OZNEnvvHjTaBXioijieQUHi5r/ZWUio2DSJPEsLZamz9qXu61JWo2Ua4nEm7TSJ+WJRw3anwmm00GS0QrfZkKcAlEtK9WFC/Dss0Jc6opc1BNKObfzLg/yEikcQevZk7JJ87GMupqguCgGqxbUrWuhXyOFdLHVpTpqFLGGuq0uDTqxQMl+w7m5DRZheLjYCtlshooK8XplZdOb9cVua5I2IZ+iROJNWpk54IlHTdO8lAnWyvhQUKDGv96ppqSkYS1KT85wHy+zkNeJ0V2AGTOg/yyUq68mQlGIaGjUvUK2tNWl40MJDXW2UgIChKjYX3eVROLV3dYk7UEKjETibVqROdCSRy04GM6erQ9bYDA4i02rMsFaULOK8+WEJtWd989/EvLKKzxgvo7HeI5B7GcRf+EWlhGc2BMWPgR33CFEYuNGYQ24aNOtQja31aXjQzEYICys6baRjjt/OeLV3dYk7UUKjETiCzzMHGjOo6YoYh+tkhKnsEV9nLvVmWAu1EzT4MucWP532QjCYsJYPfa38M47onFgISaGsI9rWU3ANVfDvR85W2LV1Z7FnGw2bLYG71ZoaJ1YNlJIqxVMViMBFj0hNRai+0ahuto2Miqq6c5fXt1tzbFDMhGgrcgnJek2+MVY0agTOqOR2bN1TTxq9t23dTqXYQtGjRJjbLNjaeMbjo+vVyYtMoq1O+L54wcpbDvUENTeveVLUrHU/94jwsZ18/vCPftEinFjPIw5lSp6cr6wYFGiUAPE5mVRmoW04Xoi6s4xm2HN51Zq803oLwwgbsc2ArOLuWxEIKF9+2GJSKR40DiC+xkb9nHp29dHu60hEwG8gFeKXbYWV8UuJRJf4hdjRTOdsEYanMZJqxW++MI5TGC3AI4fh1mznMMWnl5LGzeeNa+d5OkVl5Gd19PpLSpWXuFeFvIGXHIJ3Hcf/PznYq/nNt4XBgNWK6x6y0zvXZlEUoKmqig2GxfQc2r4bG68U3wATc6pqaaqzEqucRy1vYycCzISEKTzzmfnyR4wy5cLi6mxCGlahyUCdMtilxKJP+MXSUMtdEKXkUFSUkMn9u1rXdiipWtpGqzJiuDpP0SQnXuV0+lBVLGAt1nEX0ieMRjuXwPTp3tevbiFmJPJBOc1A+EzMqg0m1Ary6gODMeEkaMndSRth54xVmK2ZhIWo1AZ3vB8AkosFG45TPUN6fRLbrjhdn92LcXJZCKAV5ACI+ny+MVY0cpOtKvES6NrfX+oB/e/cgnbTjhbLCFUcDdvsCjkFXrfPg3u/8K1G8wTHGNOjVxzpcVGVFWHpuqoiEuqr75cXi66uXYt9KwycWlpCdYk5+dTVBtFYGUeYeUmoOH5eOWzay5OJhMBvIIUGEmXxy/GChedsLu8as6qcLiMeIcJdLtKvDhe68ABqpYeZduJ1+sPh1DBQl7nYeMyEh68CRZsh+ho79ynC9dTfJUenXU2GA1O1Zfj4hqWxqgHS8k3qQwa5Gw4VVdDraISTtMPyaefnU9LbXcfpMBIujx+MVY06kT9LL5ClEg5ERiOYmoIAbSnEKcWHIKyfTts2gQHDzIRmM71bOBKFvI6j/ZcSsIN4+CpTOjZ031DrmguU8KNGzDabOHSzZmcjM+gyqajvLxhYb49myx0YASnv7FRUAC9ejlfLki1EdEznMbbyfj0s5N7wHgFKTCSLo9fjBUOnbBFRNXP4hNCLRCqxzDUSHGpc1yhtYU492wp4cm7zzDr1NssMDuXAnyZ+whJjCdxjBF+9qRocN06sQVxQUETwXCpIxdaCIy7cQOqhijSBuZx1mxi/3nhIlMUIS7p6aKpmjgjPQfoqblgoVDXkGnWI8BC+CA9Z4OMOKYa+PKzE/euo3zAbGK3ZRJdnIcaKPeAaQsyi0zSLfCnLLLzJ0vYvVclJsqGNUxPQfpsavSiE23ZgffI17k8/esC/n1wJBoB9CGPw6QQQpW42aQkkXLWu3fDIhqAAwfEQBkc7LTt8bHBs9m8J5Ie5SZCbaVUBUagJsTz/6pXEKFvJqvq0KFmtx+2jp/E9tLBrF0r3GKNF40WHDBzbUAmuooSqq0qQTobPfrouTBxNqs3G1r87LyRht74e1JfGHRcGT2MHb8HjMwik0j8EL/YL6quE+e/MVFgLcOWFE6lwYimNnTC47iCppH7cTbP/q6Yd09cic0hAJ5PIl/p5zDznv6cT0yjdu9edMlJ9OhvQA2qG9FtNpGqNmgQDBxY77KrLrRw5sMPCdOFEhFUTlI/MdAXZ1exrcrKZTcMIi7CQRgco+0t+CJ1UeGMHgxHjggLxlFcLBYI6mUgZm4GugLnDylapyOjheUu3phAuPbw6bBYkvjPYchIl4ZLa5GPS9Jt8IstP3Q6Qi5J4vwhCItrethmg/Dgun1QSksbam1VVooBvGdPCv+9nv99vIR/nLmBapz3rJ8d8Q3PPmim791LWLYhDO1kLsnmQkpq4wg77WDA2JfUx8U5Bd7VqAhSzOsxJ4/kTGh/Ck+L5xZ9Zi8xhQfJ2pBCXC/VyRCqV8WUlBZ9kS3GlkJcf0jNfXbeSkP3i2zDLoYUGInkItNcTChGMdM7KxPKS4So7NolRs7Bgyndvp8XvxjCC2ULKcF58eOVhhz+5w9VjL93Ata802S+f4Lw0AiCB8cTYdYTgQULUfXV7tWCgvoIu+O2xyVnzei0amoDAgkOFos6e/WCgPh4Isw5aAFmIK6hHZWGaLuHmQnetia9JQx+kW3YxZACI5FcZNyNw5FhVmaTiapTxIiblSVG3127YMUKni9/hGd52KmtMXFH+dP/qlz9yzRhlXzwAZaTJUTaYzy5eooGjSf6wGZiyvM4b1Ep3mMjJjwYhgwRRS4rQA0Aam1ElZ8isKqYIGsZlWU2bDYVVYWKUAPVaigRlYUQHkdhXdX8uKBG0XYP1cOb1qS3hMEvsg27GFJgJJIOwGCAjLlWzv5govJcKSGxEfSMsaL7skTs1XL4MHz9NezfLxaDAA/yEi9zH8VEMyT6NH96IZj/d/sAUcjYwU9UFp1IlQEqDaArsxB9YDOnJ8wl2FLA+dwyzOPCiZkQDytWgMVCaGgUAeUlxORnE1yQS011MWVnj5DMaUy2dHQ6PRXVKufih9AvUgeFeehLVKwnbJDiIqvqIvsivSUMfpFt2MWQAiOReEJ7UpRcvffCBXSZmfS2R6Xz6nZoLC2F1av5bl0ZybZCejus/jD00PjL0M9RE438/PE+qEMHN1zDwU8UWi1SfAGs4VGEFOYRbCmgIi6J85UQnAKEUG9GGUpO0O/ITjQ0qmL7YA2Po8ocSnkJpJRmU1w1iciAUuKG9iLvGiFUBcfLGDAzHEZ3fHVhbwlDe9YeSVwjH1kXxS8qB/sDXspdtX2eSXF+CVU1KsGBIn1Wvc6DFCVX6U1hYSLArtc3BA7y8+HjjzmaXcQjPMcqfsp83uVd7oDYWBg2DG6+mQUJBsg7DJGXOl/HwU9kMEBYaIOHSlNV1MqypgNunTtL3b6d3vmF5BQlUxxgINhWTrQtmx7B5QQEWSgL3ENQSl/OXT6b2qAQzgQloV0CPUfjFyOIN4XBL7INuxDysXVB/GLNhz/gpdzV0g8zydmlYFESG0rN51tIq8gk4s5mUpTcpTcdPQo5OXD99WJE/OgjirN286z2e17mPmoIAuA9fsGDk35g+EhVtBETI95bUSHatlobru3gJ1JVkS2WnQ2F50SlgDxzOErdrYPYiVhorg5jeBRhA3szpmccZjNUVuoJGTsJA2Yqj+TynTKOo70nE1Ciw1bsnzN6bwqDX2QbdhH86Csi8QZ+UTnYy7TJCPHSg7Dmmti7rYQaQyJxDr78srIo9m7LY9R0E7r+bkYjd+lNgYFib/n/+z9sW7fzLvN5nI8oJN7ptJvSDhEdq0JREQwcCJ9/Lu4nNVXU8ncUy0Z+IvuuxEUnLVRV6EmeZ8SYBBcuiCr0jprbsyqC6VYbEUZRwkWgAnGE11Ry1YwUBul0fj+jl8Lgf/jh10TSHrpaLn+bjRAvPYiC46WUV6lNAsXh4VB2WqXgeBnG/m7e7Cq96fx5+PBD2LSJLdoY7mMrO3BemD0+MZcXb/iOMTf3g/j7hFh+/DGMHCk22LK32VgsG/mJVJuNWIP9Yencau4Fs5GczXrGxVtQDU2DGLokI0mdeKSQ7uKOQz7mLkZXyuVvlxHipQdRqkWg4jpFScVGGc2kKDmmN1VWwiefwMcfU1AVyaO8LeIrDiTqi3hh4ufMXRCFUmYTmWTp6WJ0jIxsWSw92JfFleZGGnQcHDibQeZMYsu6VnRbuos7ls77zZG4xNu5/B05+2uXEeKlBxHS30h1kJ6IMgvW8IbZva7MQnWQnuB+zaQoGY3iOpmZsHKlsF6ALCY5iUuIWs0jaet4eNxGwsYNx6aomKujqDmeh7bdRM/wUnSNxdJe6//sWVFTzGptWO3v5kNqTnOtkQYKx2cQG9V1ottd0V3c2ZCPt4vhzVz+jp79tcsI8dKDMCbp2DJ2NiG7Moksz3Pa7vf82NkYHXxHTcT45HZ0ixfDzp1Obd6YuJ2rowv4anc8108o4MVR/6bf8EgwjKOkXCU7q66M/wWV/DVlBBsaYiQATjt2FRTA3r3igqmporSMmw+pRc2N6lpBjK7mLu6MSIHpYngrZbOjZ39Wq7hWfr6IiTeuvNuiEeKlB6HTwdSbDKwJzaA230SwtYwqXTgBfYzMuk5X34yjGOsvnGLMx4+g274MEwmcYQQj+UFkgT38MMoDD/DK8WCOH4eZl1XC6qAmNcHiYiFEs1HdL5yzqkOMJCqi4aSQECEy9l268vNFZL+01OWH1N0WEnYld3FnRQpMF8QbKZsdOfuzD9bFxWLMzMsT92QvsOjxgOil3FWDAW6+VYfJlOSyGbsYqzWVXLXlrwxc8Wdqq2r4C7/jjzyJUTnNj4veJ+gPD9dXiBw0qG53YmvDqG+ujqqvCaYrs2AN01NpMBKpOsRI8vbA6dPQowfU1EBCQkPVyXP2+i1xLj+k7raQUJZ+6Xi62FdKYqe9KZsdNftztJySk8WkPztbjJvr18OoUULkPB4Qm9krvjVi09zzNJ3SiPnuP0z+7DeEnznGV1zFvbzCAcRK+0OanpdinuVhvYs3O4z6Ncfz0F9QCdEa9omxl/Kvj5EUfCvuIylJ3MfBgw1tBQSIOAy4/ZC600LC7max+SNd8Gsl8QYdNftrbDnZ13OYzaKy76hRYu+sVg+IvgooHTpE9IIHmbVxLacwcgcf8BE3OZ0yYIDos1vqRn1tu4n8NWVU92u6T0x9jCQqRYiKfcGK44dUW9tQ3r+ZD6m7rBfpbhabPyIfscQlHTX7s1tOis1KiNmEWlGKLTQCncFITY2OHj3aMDD4IqBkscCzz8Lf/06IFV7gIZ7macqIqD8lNBRmzoTnnxci0yw6HT1HJ2E7AmcUiGq0GVfDM3f4YAwGUXbGbqnYN7iXU/R6upPF5o/IxyxxSUfN/iIixN7vxoOZ6MpL6rO2rGF6zibMJjjY4FDmxMPBwpsBJZsNliyBP/wBCgv5lkn8mlfZx2VOp02eDD/9qbhE376eNe3ZMxcn2T7PpHiPiWpdHyKO7SIsVEEdkSruRU7RneguFps/Ir+BErd0xOzPGG/l0iOZlCsKQXENglBdaKHv3kw2GjIoq9K1zsvlrYDSV1/Bb38Lu3cDcI4YZrKWCsLqT0lIEM9swADfFVs0Y2ANGdRiIjisjOph1xMeAVeNr/KLfeMlEjvyW9iF8MWiyIs9+9MVmEgbWML204lYzlFfXDI4JIqg4jz0JSYMAxo65JGXq70BpUOHYNEiUQvMgejeYdzS5whvb0slOBhmTrcxfegpxg4tJS45gp4jjGIL4Fbi0fbAOh3Rw8VJYYjnIPeNl/gb8qvYRejoRZFeo7SUiEiVSSnUVfYVcWubDfafVYkOKqPU4XSPvFxtDSgVFYk4y8svg9VKIbHEcQ4tLIyiux5lSY+HGBQRxrVxMG9aEZcdX03NqRIqTSq9RtlQj3j/A5CLByWdiYCO7oCk/TSOYRuN4l9FEa9brR3dw1ZQZ22oqkiUSkwU/1ZXi9pftpCm1kaLXi57cEPTGkbhvDzxuysfVk0NvPIKpKTA3/6GxRrGA7xEMifYM2sRq/58iFdjnmDngTCOHIFLB1gZsG81oKAkJnI+xIg5zDcfgFw8KOlMeMWCURRlBvB3RI3vtzVNe84b7Uo8o0vNat1YG2FWUfur0tDU2vAobdrTgNJ//wu/+Q3s348GLOMWfscLnKUXADedeJ5HDRCtE00aDBB42oTpWAl9xiUSgHDrVVYCcd7/AOTiQUlnot0CoyiKCvwDmArkA9sVRflc07R97W1b4hldalbrJpUqOkrU/qop1bU9bbq54MaBA/DQQ7BmDQB7uIx7+AdZTHY6rbYWgoJERrB9oO+hK6XKqlJSIjTR5rAcxdsfgFw8KOlMeMOCuRw4omnaMQBFUT4A/h8gBeYi0dKsNjiY1qf2dgSOWQoTJojXqqogPBzVaGTqBR1rPrdStMtEcE0pVYERBPQxMvs6HTqskFv3Xvvo3kJ1YUBUOP7jH+HVV8FqxUIkf+RJ/s4D2Bz+PHr3FvoTGiqWngQHNyxBiQoSJf2ra8TvYaEOYRcvmxVy8aCkM+GNr2NvIM/h93xgTOOTFEW5C7gLIKnT+Gt8hzczvpqb1SoKZGWJmoh+Hfz3IEvBgJkMMimmhGpFJQgbPdCjFo2HzM3ivZWVsGtXw86P7qoLV1XBP/4hgvjFxVhReYuFPMkfOUf9to7odPDgg/DkkyLmv3q1eN1xW+JjlUZCq/WEFFogKYr09DqL0kdmhVw8KOksKJqmta8BRZkLTNc0bUHd77cBl2uadp+796Snp2vZ9oqw3RBfZHy5ajMsTGzfrtc3FR5N86P9MKxWsY+vorjvKLg+x2yGzZth/HjxelaWc9v26sKO7SxdKqyWvIZ50Xze5T3mO711yhQR67/sMvfdtNngxAnRj4yoTGKDS1AD/VnJJZ0ZRVF2aJqW3vKZ/oE3hpd8wDG83AcweaHdLomvyuC7mtVarWLrdsfxGLwU/G+lCdbs6Z5kKYDrc2w28fDsG3CVlzfU6XKsLnzyJLz+OixeLHaKdCQlhYUL+vPeI+LXpCR47jm4+WbxOdlx556KiYHZPzdgiJRmhUTiiDe+/duBFEVR+gGngJuBn3mh3S6JLzO+Gsew9+3zUfC/lSZYi6d7kqWgaa7PqagQr1dWNj0nIEAc374d3nkHTp0CYCtjSCOHkPgo+P3vYeFCxgYFcddR6NcPHnhAxFpcqaLBoGvGPSVrkkgkjrRbYDRNsyqKci/wX0Sa8juapu1td8+6KBcz48snKa2tNME8Ot3Tjro6x57O5VhF2E5+PqxbB0eOAJDNKJ7kj6xlFn+/dj33Lx8nHlIdb7zh0G4zqqgzGKSOSCQe4JWFlpqmrdE07RJN0wZomvYnb7TZVbmY6xgcg/+OtDn2bLUKa+DQIbHy0fFGoqLEYGxy9o7aLTZXbrr60z3pqLtzVFU0pqoN1YWPH4d//UuUdjlyhB9I4zo+YzTZrGUWAH/ePpXygAhc0qVWrkokHYdcyX+R8fqg3wytXcDeLGaziHBnZsKxY0JosrKESthxYYJ5ZLF50lF35wQEwMMPi3937oSvv4Zly+DECXIYzhw+ZiQ/8B+uq7+uosDUqc1Yix6pokQiaYkuF4H0RcFHb3Kx1zF4JaXVcUbfv78InsfGigazs0Wmlv1GGplgHltsnnTU3Tn5+fDll8Jqqa1lF6k8w1N8wg1O11MUmDdPpBwPGdLM/bbGj+nvXziJpAPpUn8JnaXg48Vex9DuisiOmQn2/Gd7x+2ZWkFBLk2wVq08d9dRd4P46dNikcqbb4r6YcCdvMnb3NmkiRtugKefhmHDPLhfT1eu5ufDtm0QGCh+/PULJ5F0EF1GYHyV/usrOtUmSI4zescVhoWFQnhOnBCFIV2YYO222FzNGkCUdnn7bZEl5kC/gTo40vD7jTcKiyU1tVG7zVkenqxcLSkRLjlNE2KSnt7wHn/8wkkkHUCX+QvoUgUf/Y3GM3q9XrjFzGYRUJ85U2w633hArRvEDaWlZIwJ4WwBVBZVEhLr4V4pjWcN5eXw6afip7KSQ6RwCXVrWiZMgD/9iXtHTObF/mJHySefhOHDXbTbkqnrThXD6jYW0+mE9RYcLNbYOLoK5RdOIqmnywhMlyr46G+4mtGrqnCLXXKJa3FxHMQrK9Ht2kVve/mWvBDwZK8U+6whLg5WrYKPP0YrKeEbpvAnfs9XXMPuQfMY9tf5QuQUhUhEkpvbZj01dVtauZqb2/CFc3QVxsXJL5xEUkeXySKTZcx9SGvT0RwHcXsQPiZGDNr5+eI1T1J+z54VwfsFC7C99z4rSqYzhm1cxQa+4hoA/nfEhzBrltOSe0dxsVqFFuzbJ/615rYiQ8zuxxw8WPxbWdkgKo7llEFksVVWiv/LL5xEAnQhC0aWMfcxrclMcPRXFha6L9/izpVUXCyKgL34IuVFlSxlPi/yW44y0Ok0VdUIClKorRXje2NcecJ6W0q5OljF5QqYliwPx1mMfc2N/VnU1tXol184iaSeLiMw/lTGvMtmrnqamVDnr7TZwHKqAiwqahBE6EF1nOk3HtALC+Gll+CVVyi8EMSr3Mcr3OtU3RggONDG/CuO8vDr/el/iesH684TVlMdwd4cG+n9XbhUW9rboPEsxp7skJcnLlReLrLJZN18iQToQgID/lHGvLOkSvuUiAhKL9jYfhBqC0LpdcpGeTEEB0GKoZZQx7Iu4eHiA3vhBVGrpbwcEwkM4CiVhDo1Gx1WyT2T9nDv7OP0/NnVYHD/wbpL+ghKNlLyg56ikxZi+7dybwNXs5h+/cRFxo1rqDjQgeLSZSc3kk5Jl/vqdWT6b2dLlfYV1ngjOUf0BCoWgvoaCCkJI4Qyqqrg+OlQLo0yoFosUFZG7TN/RPnX+yjV1fXvN3Ka8WE5fF0+DoC+fTV+e3sRd8wuICI+Hoxp4kE2M5q6S/rQVB35w2czuKKZDLHWBv/bU0nai8jJjcTf6AbD3cVDpkoLTAU6Dg6czYjTmejOm6iI7UPksV3oFIW86FRKvtxCj53fUPT9IZYyHz23sYAlAJiThhP49O/5bczlWP4odpGcO1dBpzMADqNkC6Npc0kf5SEGbNdngK6Nexu0YhZzsQZ9ObmR+CPyK+dFulOqdHOz8tJSsEYaMKVkEGI2oVaWcXbM/yN630ZSPn+dvONlPMo9vM9tlBNOH/K47pIDHL/pMQ6nzEJD4eaZMOsnzvuxOF28hdHUaNQ1n/SRpAOdb/c2uJiDvpzcSPwRKTBepLukSrc0K7c/B03VURmdgHHTR/RZ9Te+PjmQB/gLm5jo1F4+ibx4/UYmjFaIQgyIp083MyB6MJrqkpJal/Thgw/vYg763WlyI+k8SIHxIt0hVdqTWbnRCDGKmd7/XkLguv/wvvla3mVtk2wwgL594dprYVR6g6nS4oDo4WjaqnCJDz68Tr/3j0TSTqTAeBFvp0p7FBy+yGlDLc3KC9fnkLDqFeYtW8ZdlYt5m6wmbeh0GjNnKgwYAFdNshJaZEItKMUWGkGlwYjNpmt+QGxhNLUGh2Nyk2nsFh/kuXfU3j9ddXIj6XxIgfEy3kqV9ig43Pik6mohOGPHQu/ePhEbV7PygOpKEjavYvSn/6DXsS0AKMAgDjidl9jbxoK7VG6/XaGmBj5710zQqkxiw0tQdCqKzcYF9JQNn43R2EwEvJnRtFTR82mWkQtuMo1d4ijSEyaI16qq2p3nfjEHfX9aByaR2FE0TbvoF01PT9eys7Mv+nU7C1ar2NtLUZoOTJpWFxym0UklJWLRn9ksXhs1SrzezMjaFuMnNxdWrxYWTET+AXqtfYcd64vYVpnKy9zvdG7+pVdxyfH/cs01Cnf/WmXGjAZXWmmxleQtyzmZq1AZHEVyMgQGQZRmIW24RsSdLUTAXSiwLUzPyorZ1OgN7p9b4yZ9nOZ1sVOH7Z9pR60Dk/gWRVF2aJqW3tH98BT51fNDPAoO02iPFrtgJyaKcixhYQ31vubOhYICJyUxX9C1aeAzRleQunsVwX/9nE+OpbGEhyigJwALeJuh6n6OjpjLvim/xpQ8nr/pFObOFW06xm9Swk3ER5YQPTmRs2fFdi5jx0JcXBSqyYMIuAtT8ZTVyPkvdCR6kGkMtBhQss7NwFSga5f3sdPt/SOReBEpMH6IR8FhzeEks9m53pe9HEtcnNg35bXXRAkUh5n++orZKHqD5+mzu3dje3MJ6947zWult5HJB2iNaqX+se87ZCzqQ3BST1QgsVGbjsKp5paiqSoBAZCQAIXnRPdUFc8j4A6jqdUKh78V9TFDQsTA7vgMXTbZjJKXHsjjv6+ZOBuc1G7LQw76ku6KFBg/xLPgsMNJFRXOo6m98KLNJtZ3DBoEAxsKRRYdsxCzM5PKORloDl+BJjP9Cxdg+XLOv76Cd3JG8BoPcJz+TfqUEF3JTbcFEddzFMGNBlLHNh2F0xYageJwk6pDibLWRsDtbqiTJ0Wp/oICUezYvgeY2ybdKLnNBnv2qQQOKiPRgeNnmAAAIABJREFUob6mXLQokbSOLlOuvyvhGBx2xCk47HiSY+n4sjLxu8EgRt6KigbLpo5yXRRB1SWEFuYSWphLRO4+QgtzUWxW1ACN2o3fwe23Q0IC/1z4HX1y/sPD/KWJuEybXMUnn0CuScevfpLPgKqGdhyxWw+OwllpMGIN06MrEzdpq9PE1kbAHb1cQ4cKayi0roRZdra4ntsm3Si52QxVFTbC4pwVyVVFf4lE4h45D/NDPMsIcjiprExkPeXlNWzfq6oNU3lHn47NRni5mbDCE0T+900qY/qg6QLRlRYTdWIXEw7sILrgUP3pw9nlVHQyWl/DHXfquHuhQkpKsBiNV2QSc7KE+EMqMWdtWMP0FKSLYHvdJetjDw1ZVToK0mcTn52JlpdHjKJiKLdBYOvSnhp7uewFjsvLxXX27BFrbVw26SbNq6rAgi1UT6WhqcjJRYsSiefILDI/xqOMIPtJp07B1q2iXHxgoBjVq6rE8UGDxLl1mWa2klLObdhNeY/ehOhqCTGfovzIaZZot3Mvr2CgqKH9YcOYVL6W0rCe3PugjptvbqgL6ZjuZouIIqtuyUsUFkDDNCmD4lKdUwZX46yq2mor8VYTV48ro4exdRFwqxW+/VYUQO7btyHuYrOJ6+TmwsSJYvtkt0026pCtxsaxAj0rymfTa4ihSSwnL08sDJUxFUlHILPIJF7Do+Cw/aSkJLF1saMixcfDihVihh4RUZ9ppl6wEFtzFuuefeysuoyXeZCV/JQaggijnN8FvSzWgzz2GFxzDZ9bFKKiXNQFczAfVBqsh9MVUeiL8zDvMaH0TXKyHppmVekwGpNaKo7chJbiLnFxIqaTktKCXjl0qNhUxldbwjltMHI4T8ehrAaD0G7oyEWLEonnSIHxN9qzMt+VItndaD/8AFu2oOXlUXaqiA/I4FV+zQ+MdDr91ZDf8ptne6P2ioMzZ8Bmo0cPN9dvFCTX62HSJDH4W3NVBo4rI96F9eCqm61ZL9I47mI2NxzLzhZ9KC1thRjodFiNSfznW1DioG8UGOIblhWtX++8rEgG+CUSz5B/Kv6EL1bl5ebCli3w/vvsK03kDRbxHr/AQo8mp16ReIJ7L/0SevTwrCKjiyC5qtblFFTaICXco29Ya6sOtyvu4obGbTqK5fHjQmBGj5biIpG0Bvnn4gvaYoV4s7Z7eTl88IFY/5KdjYkEMlhNFpObnBocUM0N+vX8dvpe0nufES9GTxDbF589C4cPu++/l2qhtLbqcOPsYkcxyM0Vm0s2G3dxgauMZbtY1tQIzZXiIpG0Dvkn423aaoV4o7b70aNCVN55B4oaAvXxFHCUAU6nJvYo4dbeX5MR+gkxhQeJ0KUC4SIh4LvvGsyBwEBxbVf991IBrNZWHXaVXWwXA4/iLi6Q1YglEu8jBcabtMcKac0o62ghhYXB3r3w2mvYMr9gDTMxMJgJbBbnBgeju/FG5pbVsPg/GlP65zLv0l1cnnQa1VoN1qGYCvpi7GOgql8flE3fERQM4eFhqGFhIshRWuq+/16ohdLawd0XRSRlNWKJxPtIgfEmLVkhubli4HXlOvN0lLVbSAUFsG0bfPstpwp0LOGXvM2r5JHENaxnff+F8KtfiQWTMTHM3wVxl0PqkN6EmBWKK1OwhYRTaTByfNcFBh7KJHrffmLOnKYqpAcB4aEk3ZBOhKq2bEW1sxZKawd3X1QOltWIJRLvI/9svLmfSnNWSGUlfPQRREa6dp15MsparfDGG/Dll9R+t4WvqibwGq/xOddhc/gov2QqB1cf5tLBDYUaLrsMdu+G4lIdUXENYmA2wx6TgairM4g69S22fVascUkUBxg4e0BlUnwr64N5QqNnrjMamT1b16rB3RdFJC92YUqJpKvTvf90XCyyK6rRc27MbML6GFo/uLizQmw22LULRo5s3nXmbgo9bRp8+in89a+c23qYpcznDV7nCClNLhUXJ4yWyB7OVYDcNV9VJcqURcfpKCeFiFMHqY6KIwxRgNJsrssK81Ygwk2MyjB7NhkZhlYN7r4oIikLU0ok3qP7CkyjeIl9OxWr2YK6O5ODIzOI6KFrXYawKyvEZhNrUIqLRbzEZmuwchq7nhpPocvLRR9HjYJTp7iLN3iPX1BNcJNLT04xsfBujTn39ia46WHA9Qy9uFhkMYNzfTBreFRDAUpvBSJaiFHpMjJISuq+X0mJpKvRrr9mRVHmAk8Dg4HLNU3rPPVfHOIljtupRCVGEVKYR224iTNKUpPYdrMetcZmQmWlsFzs2Vg7dzYt89vY9aSqcPo0vPyycKnV1NQfqibISVx6hFfzi6vyuXvGSQazX9QwcSMudlzN0O1Gl6Y21AcLKcwj2KISZvZiIMIbmXISiaTT0N7p4h7gBuANL/Tl4uIQLzGbobwC4mLFIU1VUSvLiIpzHvc8ykC2mwm5uUIgRo4UlsuOHRAbK8TEvtzc3kh4uBCjDz9Ee/kVtu1QOcAg5tMgLsTHs3BmJe+9B5f3P8fCa/O5aaKJsOC6csFa2yyMxkZXjd6AaVIG1SdM4hnMC4ckoaLtDle1Nh9ZIpF0atolMJqm7QdQmhSp6gQ4xEsqKsR+JHYUmw1biIg32Me9VmUg63TiJzKyYcfJsLAGv9S5uuBGUJAQlldeoXDJ5/zLPJMlvMtehhJGGXP4hKgRA+Cmm+CGGxiT3I/dCywMO75WqNz59qc6uY7N6NDH/P/2zjy+quJ64N/JeyEJSQgkBEKAEEFlk0UBBcuigiKCgCiCOy51+WnrUtdii7i1FZduVqu1UusCiKIgirIJVqCABRUQEQhLCIQlJISEEF4yvz/Oe9z7Xt6aPWG+n8/9vHe3uTN3mTNzzpkz7hhibsFZLUEGzGATg+GU4tRVeNua7nFxSZSVy2ZnUQGuplaodk+950+7o8pcpJXmsH/7UXLXJNC2n61Jb2+tOxxWPJMDB2Qir8WLcW3awhfrW/FPbmYuT3OCJifTLiaed0a+x/9dtkPOX7gQlZhIj5EjoX/1ujqF8p6KSLgG6+aYwSYGwylFyFpJKbUISPOza7LW+uNwL6SUuh24HSCjPujZbU335OLdpJQ40LvLIFnmMtEOp1e9t2WLt3YnujCPVmvn4ywupEmhg6jPymCrrUnv21pPTKSs1zmUzJ7H7i+38u+j45jOc+TQtkLW4puWM6Hvdn42oDxwjV7N9zCY91TYppNQ3Rwz2MRgOKUI+UVrrYdVx4W01q8Br4HMB1MdaVYZd9PdkZNDl74Sqn2/M52oQidl+d71nl1eqDIXrdbOBxQlqe0pVODMBJRNANhb6wcPUvrRfBxfL2eq6ymmMdNvdvqfp7n1NsWE8/eQ+OUXdWYM9+2E5OeHYToJt5tjBpsYDKcM5qt2N92bZ8CYvoHrPbu8SCvNwVlcSElqe4qKoKln0kiHTQC0aiUt+RdfhG3bTiq/+vCN1+WTElzceruT226Drl3dtqxNhXVmDPfXCfHMW+ZPg3XSdBKJh5gZbGIwnBJU1U35CuAvQCowXym1Xms9vFpyFglVcG8K91S7dmf/9qM0KXRQqES4eGYoBmD/fvY99AJvf9KcBcWD+Jws7KLigg5ZtNh/jDO7OblsQD6ZCQcYOjqBtmekc/JxhDCGu2LiydlVPcEHfO+Fv05IXh6sWCEy027Q9zKdbDEeYgaDwZuqepHNAeZUU14qR14eZXPnk59dyPETDmKiy2jeLhHH6NDuTZF6Rnm0O7lrEoj6rAzlroTzc4opXb+CZYtOMD33Uj7lspOhW77gEoZHL2Hb2ePJvepuDnfuzz8PHSbje7Hf5O/yY78JNGBzxw6KDh3j8zkucpu4iGrirJYpYzwE6oQkJ8to/7w8kRN+TSfGQ8xgMPjQsFVkLhdHZ85n/beKAtUeRxSUlUNSdgG9j80n4eeBoxdXNvCx0wlt+6Vz9Js4ds5Zxp4N+XyS3Zt39W84RMsKx/+71wv0eDOVhStTad9e7DcZ34ew3/gZsFm2/luOHlWsKelJ86YLyGiXyMFzR3IiMblSU8b4I9gwlWbN4PzzRd75NZ0YDzGDweBDgxYwrl05bPxvISeS25NqayAXFSWx8b+76TM8B2dH/7r+Sg0qLy+HFSvIfX0u/57h5O3S6/mW3n7TH9xuOzcPz+Gq5/sTm+AkcUME9ht72Jhduyj61yw2lp3DjtgO7DzoIF5Ds80FdDw+n7zh15CU5KyY50qoDUN1QpKSgphOjIeYwWDwoUF/9fuzjlJ83FFB+xIfD0V7HezPKiK9o/9zwx5UrrWEIX7vPVl27eId7uchnqtwXpuYPC44M5t7rznAeWcVS0V7JAOaZ4Rnv/G1VTiduHCyYWczilu3J74YEhIhMQFKSpLI+XE3iefkUJqW4X1qJUdFVrkTYjzEDAaDjYb75btclOQWkFiQjbMgmtLEZIiyJIaDMooIrPcP2VrP3kD569NZO3Mb/XI+wh6r4Dre4WGeowwnMVGlXNzuB4YPLKZP5kEK8iHdUznban1f+40zU7Z5CTk/tgq7EHW5oNyd59hYOH7Ygcotokma7dQqTHpWLZ0Q4yFmMBjcNEwB4zbs6+/yUXuyaZq/m/iWyRw5sy9lcRINuLRJIjGnBW5yV2itl5fT/Kc1JC2fS/MVG/jzoQHM5G52cBr/42zOZr2c2KIFTUeMZeyWPaSd256Lu+Zy2oavKUmVyrysXCp/WfEWGB77DVsTxebiCN1NOKoTcCBSJTERYmIkukxsrCVEj9lPrWJAyQqdkBgX6eTg3HcUjlajy5rBYGj0RIU+pJ7hNuyvXKXYdDST1c0vZnt+Mnlb80havZDY/TspLtYc6j+S9CCh351OGDWogParP6DTs7fS6rqhfPHQF1w97wYGH/qYP/AoOzgNgHcdN8CAAXD//bBjB3FPTeaGcUVcdEY2zjapJ0Pce9lUQk3HqLVV4e/eLet+ugmxHdMpbSLpR0XJfPMAxw8UcKg0kd1l6d6nVkNASU8npGvrPDK+fg/ngk/gq6/gk09ETZiXFzKNRs0TT0jg0kiZNEl0osEoLZX016+vRMbctGwpaTQUpk+XHvfRo3Wdk9Ds2QNXXCEqkJYt4Z57ZFqNYOzbB2PGyEcVGwtt2sD48fDTTxWP/fprOO88ibp+2mnw5z9XPEap36DUIpQ6glIapTL9HPOEe5/vcqmfYwej1DKUKkKpfPf/jEql5UODa4raDfut46FZs0S2/jiYPXl5pBRkcSK+D8d79uOy0c6KDe2SEplmeOlS9OIlbF1Ryuflo/mAh9lCZ7/Xax5TTOzIS2HSGbB5M7zxBs6YGIbGONi4vozCdYlsPuN8Wv20gkS1m+49HThyLL2SC2fFMSsR2CrSM5ys7D+S2G/n06x4NzEOB33TytiXkMjmTiO55gYnGRm2U6vLXbgKqrZGz223weWX10zapaUwdSpkZkJv/w4khjrC5YLhwyVI7cyZEuLigQfk9+23A59XXAwtWsBTT0GHDiJwnn0WLroIvv8emjeX47ZulfRHjYLf/Q5Wr5b0mzaVd87iDmArsBQYHSTHBYCvEPjBa02ExFzgVeBJIA4YCMT6nBc6LT80uBrC17AfFwfdezooLEyleOsJTu/XnB7j3cJl3z6ZTWvlShkpuHatDEsHXuQBHuQFv9dIiC5hTP9cJgzJ5ZKzDxATXS6V86ZN0KULnH46CUDfjnB4ZwHHj62gbPJ40p37cR63BEbeESfz3wtkaw/PVuF0wsUTkvk07hrKs3OIcRVx3BlPVLt0bhztrGizry53YTN3S2DatZPFcGrx/vvwww8iCE4T7QbR0TBxIkyZYqkXfOnYUXppdvr0gTPPhCVLYNw42TZtmnyfb78tH/5FF8m0H1Onwq23SmNPyEDrcpQaRXAB40LrVQH3KhUNvA5MQ+vJtj2fRJxWABqcisxuk/AQFQUtYovJPL6ZdsvewXn9RGkBtmlD0bjr+WLaeul6uoULwAg+80ojPq6MCVeX88GrB8h97i3efug7Lj83V4QLiFro2DH3/MGCwwEtOybRtlkhGbH7xSW6a1fIyMCF06sDkJ4uv0pJB8DlCr/Myckw8XonF9yYQc8JXbngxgwmXu9HuEDEKriA1NbcLR610cKF0LOnCOeBA2HjRu/jiovhl7+EtDRRM/TrB198ETztG2+UFqGHH3+UB3Dllda2b76RbXZ1xccfS55iY+V6Dz/sNfGbXxXZd9/JQKHYWOjeHT79VNKYNKlivoKV1TMR3c03S76Ugh07Apdx+XLo1Uuu26ePNKT8EapMnjJcfrm0qBMS4NxzJa8gz/uee6BzZ2lRn3Ya3H23RAb3MH48XHhhxWtPmQKtW1e8XjAOHoSbboKUFLneBRdYswJ6mDtXyhwfLz2E886DZcus/W+8Ic8iLk6e15AhFd+rSPjsM3nvPMIFYOxY6dEsWBBZWikp8lta6p3+uHHe3+jEiZCdDRs2WNu0Lo888365GGgHvFxN6VWgwfVgYjumU+qMp/WW1cTm7yM+Zyvx+7YRezAbhYYlkEsr5nE5HzOGRQyjhDiyyCSTndLKGDKErj17MeDvBZzRxcG4a+O4ZISDuDjA1QLei6vYA9i/X15Uf7W6nwq3ujsAETlnVYe7cASqtipPRLZrFzz0EEyeLPf4wQfh6qvlo/K02n7+c6lQnn1Wwgq8/roIzKVLpZL2x+DBYjfzTFO9fLlUsF99ZR2zfLlUfp7W56xZcu/uuEOutW0bPPaYjIF6/nn/1ykuFkGWliY2qpISue7hw3DWWZGVdckSabk+/riUD0Rn74+cHBgxQgTB7Nmyft11FW0C4ZRp82b42c9EgLz6qlSAa9fKy+opY1kZPPOMNLJ275b/48fD55/LMbfdJvnJyrIqYa3hrbfg+uultR8uY8dKT+H550U4TJsmwmvdOnn+27bBVVfBvffKvpISaSx47IPLl8Odd8KTT4r99MgR0WQUFFjXKCuT/AUjKkoWzz3q1s17f5Mm0KmT7AtFuVsTkpMjz7dDB+sZFxXJPe3Sxfucrl2ta/foEfoa3jRHqYNAEjI55FNo/aFt/3nAIaA/Sv0BOA3YDDyG1vMiTMsvDU7ApGc4WXXepVx0X3uiyqRFpIHv6MknjGIel7Oac9E+nbOPb5nLvc+2lpd8/nxUYSFf3zMDVV4GRYlwbCTEBQgpX1oqH1hKirzAvv7FfmwbdT55Y1XdhcNUtVXLRGR5edLD9FTy5eViSP3xR/ngfvhBKu4335RWLUiF3rOn6LU9FZwvgwbJg1i3TlrvX30l57/xhnywXbrItkGD5HitpfK/8Ub429+sdGJipLX+2GNWy9POm2/CoUNSIbd1T7/QqZO0qCMta79+1vn9+we/b3/8owjM+fOllQ/yHl5/vXVMuGWaOlWe81dfieADuPhi6/jUVHjlFWvd5RIhMnCgCM2MDDm+fXtRB02dKsctXSo9sJtvDl4WOwsWyD368kvpdYAI3cxMESZ//7s808REWfdw2WXW/9Wr5f147DFr22gfbVKnTrBzZ/C8TJliOUwcPmzZS+y0aCH7QvF//yd5B1GbLVxo9Vjz8+XXN/0WLaxrR8ZW4GFgPZCA2G0+QKkrbYIhDYhHotxPBrYhU6rMQamz0fr7CNLyS4NTkTmdMOza1uR16M1yBnEXfyODXfTmWx7nGf5L/wrCpXt3SBrUUz4km95KtQ2gt/L0AEaNkpfU5ZJzDx2SltHy5VKjQkDbRm2F5nK55PvetEl+I1G9BSUMVZuvH0Cl1YCZmd76a08rMTtbfteskeuOH28dExUl6//5T+B0O3eWCJ2eHsvy5dLCPucca9t//mMJmC1b5CZefbVk3rNcdJG0kO1qCjtr1oiqpq1tbp9zz5WeUaRljYTVq6VS9wgXsPT5HsIt05IlMnOqR7j449//hrPPlpc7OtrqOW7ZIr9RUaISfOstq2cwfboId9+eXKhypaZawgXkgxk1ynrePXrIt3fTTaIq9W2x9e4tQuj+++W521VRHubNk2cXbLn9du9z/M3eq7X/7b78+tdStvffl/Jdcgnk5oZOP9j2QGj9Nlq/iNZL0HouMApYBfzWdlQUYsx/HK3/jtaLgGuALESgRJKWXxpcDwak/i+75QpmTj+HV7dWDN7scEhvf8wYWTp1cu/YFb7eyoWTHFc6UV8uI7ZpKi06JOFITZVWal6etD769JFz/dg2IrK1V1LHVC29h2CEULVVmxrQt9XWxD25QUmJ/O7dK/fFXpGCVODFxWJbi4nxn/agQSJMrrpKKtqBA61tAwfKDKMeAXPwoPzaW8J2POoiX/bt87LNncTftlBljYR9+6QBZCcuTu6Vh3DLdOhQYFUcwJw50gu66y5RsyUny3O54grvvN98s/Qqly6V3tgHHwRWLQZi717/wrl1a0sF1rmz2JV+/3spW3S05OVPf5L7PmyY9Cz//GfZlpAgPbtp06zWXbdu4anIPLRoYfU07OTn++/Z+JKRIUu/fiJcOnSAl18WNZ7nfN/0PT2XcNIPhtYapT4E/oBSDrQuAzzjDZbajitDqWXA2RGm5ZcGKWAAHJMf44rz4G/uXnzz5nDppWKjvPTSABVsKL1VQQHs2kX+nqMsXpVA8REXHTYXUti8PU13Qt++iSQOHiwveVaWCJh+/fwKg7BHxVdSStSaF3EQVVutqQHbtJGLFRd7C5ncXFkPJFxAhMczz0grtls36YkOGgT33SetkGbNrErac79fe01a6r7Yjbt20tJExeXLgQPhla+ypKWJbdDOsWPe40nCLVNKilTsgXj/fVH52dVsdoO6h8xMqdynT5dvpLxcXsZIaNOmYrlAnrf9mxg5UhbPS3/fffCLX8CMGbL/pptkOXAAPvxQejPNmolQgshVZF26VLS1lJbC9u1i74mEZs3k+tu3y3p8vHzIvul71n1tM5XHLlEDuRkrIBxHgpATRzZYAQNiw33kEdF6nH9+GDbEYHqrI0dg0SLKomPY/I2DdrqMBF2AbhpDbEupLNeuhcGDHdKTOXFCpFqQWjykrd0tJcrKFXmx7Tl2zO1HUF6AI4SUqA9exLUWob9fP5Gks2dLKxqk5Tl7dmADv4dBg6SCee01eWE823buhHfflRfHIyU7dxY1144d4lQQSf7eeUcG4XnUZKtXV1R/hEMkPZp+/eCf//QWvB/6qMTDLdPQoeIM8MwztlAUNo4dqyjI33nHf1q33gq33CIeW2PHRt76Pu88qdiXL7eeWXGxCJErrqh4fFISXHutCLyVKyvuT00VB4cPPxRdsod587w8S/1iVzWMGCHvzM6d0vsAcTw5flxatZFw8KA0SkaM8E5/zhx4+mnrnZw5Uz7ySFSM/lBKAVcA39p6HJ8DLmAo8KP7OAcwBPgywrT80qAFTJMmVmPEL76qp1at/Out8vLEY+X888krS+ZQLKS2hPK9pTTbvp7itI7Exzs4cFAOTU0lbE+qoLb2nByO7itkzd72FB/j5HQDTeOS6NdmNwlBpESdOxFQixH6u3YVYXvPPdIQ8HiRbd7sbXj2R+/e0lpcvlzUOyCSv1s32fbMM9axUVHwwgtwww1ynREj5CXbvh0++kgEmq+aDkQt9PTTYiOYMkUq4ylT5EWJitDM2aSJ9CpmzZJKJTZWelgewWPnvvtExTJqlAzIy8mRAXp2O0q4ZZoyRQTW4MHwq19Jj2bdOvm95Rax9dx9t9yv884TN+zFi/2XYexYMWj/73+Sn0gZPlx6lxMmyAeekiJqtmPHxGEBxFi+cqVU7Onp4mb+/vtWA2TKFPlYL7hAvNDWrRMBZK8wIvXKuuoqKf+4caIGLCiQXtG113rb1YYOlV/P/XnhBenNDR4sdVBWFrz0kgjsO+6wznvoIRHaN9wgjYE1a6Scr7zibYNRaggyyWMf95YRKHUA2ITWm9zHLAM+QLzC4oGfA/2BsSfT0XovSr0M/N4tNLYiRv52gPXgwkkrAA1awAQlkOrp/PNlrIBdb3X8uFRayckc2yUVPcCx1pkkbVtH3P6dHEvriCPK3bCsJk8qV/5RNmxyQAsRaB6KimDDJgd9C4oCPqD6ML9XrUbof/116a4+9ZToqXv0kNA1oXowUVHyzBcssFrDIL2YjRsrnj9hggikZ5+V3oHDIR4/o0b5r+RBKugFC0SATZggaqLnnpOxJs2aRV7WV18V9+Vhw+TdzMqSNH1p21Yq+l/+Usb2dO0qg/TGjIm8TJ07iwH90UetUePdusk5IBXh9u1izygpEYHz7rv+Pd1iYkSQLV8uZagMc+aIoLvvPrneueeKI8Lpp8v+nj2l9/DAA/IBtmkjlfKTT8r+fv2kEp8xQz7MDh1E1XXvvZXLD4iKZMECaehcfbWUc+JEb082qPhh9uolH8nMmZKXdu1E8P32t94Ddk8/XdJ/4AG5f2lpIpy8R/EDTEV6GR7+Ztv+hPv/VuA+oA2i7vofMBKtvQcAwkNAEfA4kAysA4aj9TbbMeGmVQGlQxm5aoC+ffvqtb6DpqoTl0vcWpWq2LT2eCPt32/prfLzpTWUns6BA7B6jVXhN835iShXKa64ZhwqcNCzexkpHSzpEepSwWwhe1buYuufPiHujPYV9h37aTen3zuKtgP892Cqct3qxtN7MxH6bWRlyUjt116LzEW3MeBySYV+yy3SIDBUG0qpb7TWIQLa1R8aZzXgz0BRVmYZ5Natq2icd7c6kpMlYKWnsiyPjiW3/1gKipw4SopIujoeMqrHk6ogPv1k9GdXvCUlnEUFlMUlciQhnbb+T61X83uZCP2IKig9XSrWXbtkPTXVO2pAY6e0FL79Vno2hw55q38MpySNT8C4XKKPzc0V/XVyshgI166V38JCCcmwdaulw7IZExxJSfTtK4cX7C7gqEpkS0kGCSlOqbh9VF5VsYUkNHeS1W0kZ++dT+yB3WiHA1VWhqtpIlndk+y+AAATvklEQVTdRnJ6UvDHY+b3qkcoJYMLc3JEdTJokNgNKqMia6jk5Igqq1UrsR2YeG2nPI2rKvIYQ3bulMFf+/fLx378uBg+U1OlIsjMtEYDenRJtu5AosPB4I5lHG6fyKH+Izm9rTNgxV0VW0h6OjRJS+aHVtfQuiwHR0kRZbHx5DrSaRLlDMtIbnoPlaPK4W18efRRWU5lMjNDjysxnFI0HgFjHxhy1lnWgKwjR0QtNmCANPM98cQcDm8dlk93wBEfT8v0dFqGqHWq4kllyTUnW4pk2uOyEjONfU1T4wNUDQYD0JgEjK8xxKPnKiyUZedO6br37WvptHx1WJXoDlTVFmLUXLWLmebGYKg9Gs+n5GsMSUwUt9SffpJ9XbpIzyZEkMrKUFUhYdRctUd9GKBqMJwqNB4B488Y4nDIAKgNG0TguIVLWZlMFFZSnEi5K510V9VbrdUlJKrdNmDwoj4MUDUYThUaT9UVyBhy9KgMBouLg927OVriYON3ZRTqRLJ7jaR4gbPe6N+NbaDmqQ8DVA2GU4XGI2CCGUPcI5ldu3JYPKuIst7xNMlMJ8XhJIX6oX83toHaodbC2xgMhoY3H0xQ7PO4DB4sv9dcI9udTnKcGexp1pXoThloh1VbJyVJryEnp+6y7rEN2Cs9qB95a3Ds2CGS+pOKU4sHm+ZmTNKXOKNV4HlfPMyaVXGO9Uh48EH/oV/qM0rBX/9a17kIjdYS3qZ9e9FaDB4M69eHPm/KFAk/1KyZtDT69pXQLr4UFEhkhhYt5OO87joZVGpn4UKpdzzDITzRmO088YQ1JbbvYo/f5rNPQx+U0ijlHaVTqb4o9QVKHUKpPJRahFJ+ZryrXRpfm7g+hJevBPU5bw2ONm0k9E+AEOcBnTKCzF3mxaxZEg130qRqy7Khmvj97yU8zbRp8vxffFHioW3YILG9AnHkiDzPbt3kg5s9W+KMORwS5NLDhAkSBfkf/5A4d488IsE97dNwL1gA330nQS89Uwf4ctttFSMwf/QR/OEP3hGWfaJDDx0wYPNiaAl8fXKjUu2BRUiMMHe0Tx4CvkCpnmgdYk6CmqPxCZgAuFzS+MjOlph1Ycx6XKsY20A1EhMTcrph47nXCCkpEQHz2GMSkBJk/FtmpvS+nn468LkvveS9fsklEgz1rbcsAbNypUzPvWyZFTi1bVuJLr1okRXYc9o0CVIJMimaP9q1qxjp4KmnRCj27m1t83mPy2UOlpbAe7bNI4FEYBxay4xlSq0ADgKXASFCjtccjUtFFoC8PAkMuXatCJgwZz2uVey2ATv1IW81xpIl0vW36/8GDBDJb5/Zr0cPmDzZWt+1S1qXyckSyXj4cO8Jv/ypyI4fl2jHzZtL+PeHHpI57f1NRXvwoARETUiQqMP2SbYmTZJZGpcts1QX/lQgHvLzJZx7fLz0rOzTA9gJVSaQcPUPPyzxzmJiJKy/fc75t96S6NDJyaLCufBCeek9zJ8vre6sLO90s7Jk+9y5gcvhj7/+Vbw0Y2IkErBvJZ2dLVGHW7USdVWnTvCb31j7N260ZgeMj5do0C+/HFke7KxYIT2Rq6+2tsXHyyyEn4UM/FuRlBTvqZY/+0xm1bRH5T73XHkO9vQjnaIBrFlyQ0zOdp1EPC4C5tk2RyPzuthmmuOoe1uEcy1XL41ewNiN55mZEmU8Odl6njt3ek0zX2cEsw3Udd5qjAEDpDvpUS8UF8M330gI+a/dGoC8PKmIPNMa5+VJJfrjjxLWftYs0XMNGyYVcCAefljsJlOmyJwbu3ZZrUxffv5zCbE+Z46EVb/7bplADKSCvPBCmR1y5UpZKoZTt7j5Zql8/vhHiaz8xRcV1SbhlElrCcP/yiuSn08/ldhnnimRQQTrjTfKvCjvvist5MGDrVkTPXOn/Otf3tefPl3CKAWaVtkfr78us0eOHi0Td40fL+H17fOt3HijvMSvvSb3YPJk7wm+Ro+WxsTbb4tw+8UvrFYfyGyYLlfwxd7t37zZGppgp2vXijNFBsLlkkbBO+/Is7LPVLl5s3+1ayTpB2L2bJnEcOLEwMdozSgRMB+jdbFtzwdAMfACSrVCqVbAS8Bh4P2qZayKaK1rfenTp4+uLXbu1Prll7WeO9da5szR+o03tH78ca1XrND6xIlay05ITpyQPG/aJL/1KW81Qv/+Wt99t/xfvFjrlBStJ0zQ+pFHZNvHH2sdFaV1QYGsP/641snJWh86ZKWRl6d1s2Za//Wvsp6VpTVoPW+erB88qHVsrNbPPWedU16udbducpyHpUtl/Te/sbaVlmrdsqWVH621vvJKrYcMCV22DRskvRkzrG2FhVq3aKF1hw7WtnDKtGCBpPXxx6Gvq7XWZWXy8nTurPXUqdb2yZO1zsyU8mstvx06aP2rXwVPD7T+y1+stNPTtZ40yfuYu+6SPB87Juvx8fLB+ePAAUnzu+8CX3PKFDkm2GK/j08/rXVSUsV0Xn9djj1+PHgZV6600nU6tX71Ve/9w4ZpPWZMxfOuu07rAQP8p5mSIuUIxYUXan3OOcGPWbbMk7/LtW+9Cr01ZNvuTY6GXhWOq+Wl0fdg/BnPHQ5psLVrF3LW41rHYxvo2lV+61PeaoRBg6wezPLlsj5kiPe2Xr2sqMSLFkk3tFkzqxWbmAh9+nirg+x8/73o50ePtrYpJaoTf1xyifU/OlpaxNnZkZdtzRr5tV83IUHybyecMi1ZIl1ve1q+/PCDTCncurW85NHR0ivassU65pZbpNv+5ZeyvnSprEcyZ012tnSxx4/33j5hgqiovv9e1nv3FhXe9OnSY7STnCyeXnfeKd5a+/dXvM7tt8s9DLbMm+d9jj+VpycAp799dnr0kDQXLhQbzj33iG49nPRDpR2MvXtF5RpCPcZ771EAZchUx/Y8tQFmA98AI9zLN8B8lKpTS2OjFzDGeF7PGTxYPHzy80WoDBoky9q1IhQ82zwcPCgVUnS097J0qahj/LFvn/ympnpv91334DuHfJMm7qlMI2TfPhEU9imMQWwSdsIp06FDYsMJRGGhCMbdu8Vz6quvpLLs1cs77x07itrvzTdl/c03xY7QvXv45dq7V35bt/be7ln3BJqdOVPcfe+/X+xGvXtb0whHRYkKKi1NhF5amjzndeus9NLS5JxgS7du1vEtWsh98P3g8/PFrhUdHbxc8fGS32HDxJ50ww3iJWZP324btKfv+85EwqxZIqQmTAh8jMsFH3zAZ3AYrUt99j6EOGxdhdYL0HoBcCUijB6sfMaqTpUEjFJqmlJqs1LqO6XUHKVUFe5yzVAdxnOXSxpgmzbJr8tVM3k9JfnZz+Tj+vJLWLVKBE737tIyWLxY5nW3CxhPK95fazaQgdjjnnrggPd23/XqJi1NKjxf25Bvaz2cMqWkWBW7P1aulJ7F22/L2IyBA6Wy9H3xQWxGH3wAe/bAhx9GPuOmR9D5liM31yoPiIfV9OkiHFeulPsxerQ1bqRLF8lHfr704kpKxOBYXi77n3yyotD1XTp1sq7fpYsIl61bvfMVyHYSinPOEYF94oSVvj9bS2XT9zBjhjwv3wB5dhYvhgMHeBfy/OztAmxE6xMnt4gQ2gh08nN8rVHVHsxC4CytdU9gC/BYiONrnaoazz0eaJ98Io3CTz6R9Tx/j9kQOS1aSBDSl14Stc7ZZ4u6YeBAmdfe5ZL/HoYOFaN/9+5SgdqXzp39X6NHD5l8zu4yqnVF9Uq4hNuj6ddPfu3eWUePigrGTjhlGjpUXjo/g0cBS4jFxFjbVqwQw78v48ZJGSZOlMo8mGHZH+3aScvsfR/78axZoubr0cN7e1SUuNtOmSKOHDt9hmVER8NFF8lc9Hv3Wr2ESFVk558v17fnq7hYjrGPLQmXr7+Wsnp6PiNGSK/0P7YBU2vXihNFZdIHeT6rVoWlHiMtjflQ6GfvTuAslGpycotSMcBZwI7KZax6qJKGX2v9hW11FXBVoGPrkspGOzbhW2qJwYOlpT58uGUwGzRIXInPOMN7gNwDD0gr/aKLxOuobVtpOS9bJoLI34eakiKeYVOmSGXRtauoho4cqZzuvEsXEVYffWRVtv66wt27S4v9rrvkWm3ayBiJpk29jwunTBdfLPfn2mvht7+V1vXevWKj+vvfpQJPSJByPvyw9GaeeELS8iU2Vno5L78saUeq3omKkrTvuEPu7cUXS15feUVG0cfGykcyfLh4kp15pniPvfCCPMuuXWUg4oMPilqoY0c4fFgGGfbqZfWAAt3XQMTGyqRvTz0lDRfPQMvycrmvHt56S9Ry27aJ6s5jg7r2WsnL0aPiQThjhpTJw4ABVpmef94aaDlwoDUGBiQ9j/2ttFRUH7NnS8XjK4hmzJBK5KogVefx4/KuTZpE+Z/+5O+IfwC3AXNQ6m+Ia/LdQBvgtfBvYA1QXd4CiF/29UH23w6sBdZmZGSE9qqoB/jzQPMsL78s+w3VwIwZ4vnyzDPWtlWrZNvNN1c8fs8e8WBq1UrrJk3Ek+i668RrS+uKXmRai2fTnXeKl1Pz5lr/4hfi3WP3OvJ4kX3/vff1hgwRzzEPBw5oPXaseINBcC+hvDzximvaVPI7dap4bNm9n8Ipk9ZaFxfLuW3byjGZmVr/+tfW/s8+07p7d/GY69FD6/nzK+bdw8KFkveFCwPn3Y7di8zDX/6idadOWkdHa33aaVq/+KK1r6RE69tu0/rMM7WOixNvqpEjLa+x3Fytr79ezouJ0bp1a60nTqz6R1VeLt5kbdvKfRg4UOv//c/7mDfflPJkZcl6fr7c6w4drLxceKHcP18OH5bnlJSkdWKi1tdcI++Dv/SDebx56NVL6+HDg5dpzhw5f+VKDazV/upYGKphuYY897JMwwV+j63FRWmPh0UAlFKLAH8xFiZrrT92HzMZ6AuM06ESBPr27avXBvL4qUds2iRqMX+NqJwcaXh37Vr7+TJUE8OGiX592bK6zknt8/DDYoT3DLI0NAiUUt9orfvWdT7CJaSCR2s9LNh+pdRNwChgaDjCpSFhPNAaEUuXwn//K6qlEyekcl28uKIdobHz44/ScnrlFVEZGuFiqEGqZEFQSl0KPAIM0d4jSxsFJrR7IyIhQfTYv/udGOjPOEM8nILpvhsjd9whgnb0aPjlL+s6N4ZGTkgVWdCTldoKxACeeNWrtNZ3BjkFaDgqMjCTgBkMhvpDo1ORBUNrfXp1ZaS+UlkPNIPBYDjVMdVkGJjQ7gaDwRA5xsJnMBgMhhrBCBiDwWAw1AhGwBgMBoOhRjACxmAwGAw1ghEwBoPBYKgRjIAxGAwGQ41gBIzBYDAYagQjYAwGg8FQIxgBYzAYDIYawQgYg8FgMNQIRsAYDAaDoUYwAsZgMBgMNYIRMAaDwWCoEYyAMRgMBkONYASMwWAwGGqEKs1oWemLKnUA2FlNybUEDga4EtCkCTiioKwcSkuh9stbTwhynww2zH0KH3OvwqM671MHrXVqNaVV49SJgKlOlFJrG9IUonWFuU/hYe5T+Jh7FR6n8n0yKjKDwWAw1AhGwBgMBoOhRmgMAua1us5AA8Hcp/Aw9yl8zL0Kj1P2PjV4G4zBYDAY6ieNoQdjMBgMhnqIETAGg8FgqBEanIBRSo1XSm1USpUrpQK6/imlLlVK/aiU2qqUerQ281gfUEolK6UWKqV+cv+2CHBcmVJqvXuZW9v5rCtCvR9KqRil1Ez3/v8qpTJrP5d1Txj3aZJS6oDtHbqtLvJZ1yil/qmU2q+U2hBgv1JK/dl9H79TSp1T23msCxqcgAE2AOOA5YEOUEo5gJeBEUA34BqlVLfayV694VFgsdb6DGCxe90fx7TWvd3L6NrLXt0R5vtxK3BYa3068BLwh9rNZd0TwXc00/YO/aNWM1l/mA5cGmT/COAM93I78Eot5KnOaXACRmv9g9b6xxCHnQts1Vpv11qXAjOAMTWfu3rFGOBf7v//AsbWYV7qG+G8H/b7NxsYqpRStZjH+oD5jsJEa70cyAtyyBjgLS2sAporpdrUTu7qjgYnYMKkLbDbtp7t3nYq0VprvRfA/dsqwHGxSqm1SqlVSqlTRQiF836cPEZr7QIKgJRayV39Idzv6Eq32me2Uqp97WStwXFK1knOus6AP5RSi4A0P7sma60/DicJP9sanT92sPsUQTIZWuscpVRHYIlS6nut9bbqyWG9JZz345R4h0IQzj2YB7yntT6ulLoT6fVdVOM5a3icku9TvRQwWuthVUwiG7C3pNoBOVVMs94R7D4ppXKVUm201nvdXfH9AdLIcf9uV0p9CZwNNHYBE8774TkmWynlBJIIrgJpjIS8T1rrQ7bV1zkFbVVhckrUSb40VhXZGuAMpdRpSqkmwETglPGQcjMXuMn9/yagQs9PKdVCKRXj/t8S+BmwqdZyWHeE837Y799VwBJ96o1KDnmffOwIo4EfajF/DYm5wI1ub7L+QIFHhd2o0Vo3qAW4AmkNHAdygc/d29OBT23HXQZsQVrjk+s633Vwn1IQ77Gf3L/J7u19gX+4/58PfA986/69ta7zXYv3p8L7ATwJjHb/jwXeB7YCq4GOdZ3nenqffgdsdL9DS4EudZ3nOrpP7wF7gRPu+ulW4E7gTvd+hXjkbXN/a33rOs+1sZhQMQaDwWCoERqrisxgMBgMdYwRMAaDwWCoEYyAMRgMBkONYASMwWAwGGoEI2AMBoPBUCMYAWMwGAyGGsEIGIPBYDDUCP8P9KxIeOVzCA8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ============================ step 5/5 迭代训练 ============================\n",
    "\n",
    "# 定义tensorboard的输出路径\n",
    "writer = SummaryWriter(comment='_test_tensorboard', filename_suffix=\"12345678\")\n",
    "for epoch in range(max_iter):\n",
    "\n",
    "    # 分别对两个模型进行训练，得到训练结果\n",
    "    pred_normal, pred_wdecay = net_normal(train_x), net_weight_decay(train_x)\n",
    "    loss_normal, loss_wdecay = loss_func(pred_normal, train_y), loss_func(pred_wdecay, train_y)\n",
    "\n",
    "    ''' model.zero_grad()\n",
    "        optimizer.zero_grad()等价'''\n",
    "    optim_normal.zero_grad()\n",
    "    optim_wdecay.zero_grad()\n",
    "    \n",
    "    # 反向传播\n",
    "    loss_normal.backward()\n",
    "    loss_wdecay.backward()\n",
    "    # 参数更新\n",
    "    optim_normal.step()\n",
    "    optim_wdecay.step()\n",
    "\n",
    "    if (epoch+1) % disp_interval == 0:\n",
    "        # 每迭代200次，进行显示一次\n",
    "        \n",
    "        # 可视化\n",
    "        for name, layer in net_normal.named_parameters():\n",
    "            # nn.Module里面关于参数有两个很重要的属性named_parameters()和parameters()，\n",
    "            # 前者给出网络层的名字和参数的迭代器\n",
    "            # 而后者仅仅是参数的迭代器。\n",
    "            writer.add_histogram(name + '_grad_normal', layer.grad, epoch)\n",
    "            writer.add_histogram(name + '_data_normal', layer, epoch)\n",
    "\n",
    "        for name, layer in net_weight_decay.named_parameters():\n",
    "            writer.add_histogram(name + '_grad_weight_decay', layer.grad, epoch)\n",
    "            writer.add_histogram(name + '_data_weight_decay', layer, epoch)\n",
    "\n",
    "        test_pred_normal, test_pred_wdecay = net_normal(test_x), net_weight_decay(test_x)\n",
    "\n",
    "        # 绘图\n",
    "        plt.scatter(train_x.data.numpy(), train_y.data.numpy(), c='blue', s=50, alpha=0.3, label='train')\n",
    "        plt.scatter(test_x.data.numpy(), test_y.data.numpy(), c='red', s=50, alpha=0.3, label='test')\n",
    "        plt.plot(test_x.data.numpy(), test_pred_normal.data.numpy(), 'r-', lw=3, label='no weight decay')\n",
    "        plt.plot(test_x.data.numpy(), test_pred_wdecay.data.numpy(), 'b--', lw=3, label='weight decay')\n",
    "        plt.text(-0.25, -1.5, 'no weight decay loss={:.6f}'.format(loss_normal.item()), fontdict={'size': 15, 'color': 'red'})\n",
    "        plt.text(-0.25, -2, 'weight decay loss={:.6f}'.format(loss_wdecay.item()), fontdict={'size': 15, 'color': 'red'})\n",
    "\n",
    "        plt.ylim((-2.5, 2.5))\n",
    "        plt.legend(loc='upper left')\n",
    "        plt.title(\"Epoch: {}\".format(epoch+1))\n",
    "        plt.show()\n",
    "        plt.close()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
